import sgqlc.types
import sgqlc.types.datetime
import sgqlc.types.relay


schema = sgqlc.types.Schema()


# Unexport Node/PageInfo, let schema re-declare them
schema -= sgqlc.types.relay.Node
schema -= sgqlc.types.relay.PageInfo


__docformat__ = "markdown"


########################################################################
# Scalars and Enumerations
########################################################################
class AccessKeyIndexEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `account`None
    * `user`None
    """

    __schema__ = schema
    __choices__ = ("account", "user")


class AccountNotificationDigestSettingsModelDigestType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ANOMALIES_DIGEST`: anomalies based digest
    * `INACTIVE_DIGEST`: inactive monitors digest
    * `MISCONF_DIGEST`: misconfigured monitors digest
    """

    __schema__ = schema
    __choices__ = ("ANOMALIES_DIGEST", "INACTIVE_DIGEST", "MISCONF_DIGEST")


class AccountNotificationRoutingRulesModelMonitorLabelsMatchType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AND`: AND
    * `OR`: OR
    """

    __schema__ = schema
    __choices__ = ("AND", "OR")


class AccountNotificationSettingsModelNotificationScheduleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BACKUP_OR_FAILURE`: Backup Or Failure
    * `DIGEST`: Digest
    * `REALTIME`: Realtime
    """

    __schema__ = schema
    __choices__ = ("BACKUP_OR_FAILURE", "DIGEST", "REALTIME")


class AccountNotificationSettingsModelType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALATION`: Alation
    * `AZURE_DEVOPS`: Azure Devops
    * `DATADOG`: Datadog
    * `EMAIL`: Email
    * `GOOGLE_CHAT`: Google Chat
    * `INCIDENTIO`: Incidentio
    * `JIRA`: Jira
    * `MSTEAMS`: Msteams
    * `MSTEAMS_V2`: Msteams V2
    * `OPSGENIE`: Opsgenie
    * `PAGERDUTY`: Pagerduty
    * `SERVICENOW`: Servicenow
    * `SLACK`: Slack
    * `SLACK_V2`: Slack V2
    * `WEBEX`: Webex
    * `WEBHOOK`: Webhook
    """

    __schema__ = schema
    __choices__ = (
        "ALATION",
        "AZURE_DEVOPS",
        "DATADOG",
        "EMAIL",
        "GOOGLE_CHAT",
        "INCIDENTIO",
        "JIRA",
        "MSTEAMS",
        "MSTEAMS_V2",
        "OPSGENIE",
        "PAGERDUTY",
        "SERVICENOW",
        "SLACK",
        "SLACK_V2",
        "WEBEX",
        "WEBHOOK",
    )


class ActorType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AI`None
    * `HUMAN`None
    * `assistant`None
    * `system`None
    * `user`None
    """

    __schema__ = schema
    __choices__ = ("AI", "HUMAN", "assistant", "system", "user")


class AdfJobRunModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CANCELLED`: Cancelled
    * `CANCELLING`: Cancelling
    * `FAILED`: Failed
    * `INACTIVE`: Inactive
    * `INPROGRESS`: InProgress
    * `QUEUED`: Queued
    * `SKIPPED`: Skipped
    * `SUCCEEDED`: Succeeded
    """

    __schema__ = schema
    __choices__ = (
        "CANCELLED",
        "CANCELLING",
        "FAILED",
        "INACTIVE",
        "INPROGRESS",
        "QUEUED",
        "SKIPPED",
        "SUCCEEDED",
    )


class AdfTaskRunModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CANCELLED`: Cancelled
    * `CANCELLING`: Cancelling
    * `FAILED`: Failed
    * `INACTIVE`: Inactive
    * `INPROGRESS`: InProgress
    * `QUEUED`: Queued
    * `SKIPPED`: Skipped
    * `SUCCEEDED`: Succeeded
    """

    __schema__ = schema
    __choices__ = (
        "CANCELLED",
        "CANCELLING",
        "FAILED",
        "INACTIVE",
        "INPROGRESS",
        "QUEUED",
        "SKIPPED",
        "SUCCEEDED",
    )


class AgentModelAgentType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DATA_STORE_AGENT`: Data Store Agent
    * `REMOTE_AGENT`: Remote Agent
    """

    __schema__ = schema
    __choices__ = ("DATA_STORE_AGENT", "REMOTE_AGENT")


class AgentModelAuthType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AWS_ASSUMABLE_ROLE`: AWS Assumable Role
    * `AWS_IAM_AUTH`: AWS IAM Authorization
    * `AWS_VPCE`: AWS VPC Endpoint
    * `AZURE_FUNCTION_APP_KEY`: Azure Function App Key
    * `AZURE_STORAGE_ACCOUNT_KEYS`: Azure Storage Account Shared Key
    * `GCP_JSON_SERVICE_ACCOUNT_KEY`: GCP JSON Service Account Key
    * `GCP_WORKLOAD_IDENTITY_FEDERATION`: GCP Workload Identity
      Federation
    * `MCD_SHA512`: MCD SHA-512
    * `OAUTH2_CLIENT_CREDENTIALS`: OAUTH 2.0 Client Credentials Grant
    * `OAUTH2_PASSWORD`: OAUTH 2.0 Password Grant
    """

    __schema__ = schema
    __choices__ = (
        "AWS_ASSUMABLE_ROLE",
        "AWS_IAM_AUTH",
        "AWS_VPCE",
        "AZURE_FUNCTION_APP_KEY",
        "AZURE_STORAGE_ACCOUNT_KEYS",
        "GCP_JSON_SERVICE_ACCOUNT_KEY",
        "GCP_WORKLOAD_IDENTITY_FEDERATION",
        "MCD_SHA512",
        "OAUTH2_CLIENT_CREDENTIALS",
        "OAUTH2_PASSWORD",
    )


class AgentModelPlatform(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AWS`: AWS
    * `AWS_GENERIC`: AWS_GENERIC
    * `AWS_PROXIED`: AWS_PROXIED
    * `AZURE`: Azure
    * `GCP`: GCP
    * `GCP_PROXIED`: GCP_PROXIED
    * `GENERIC`: GENERIC
    * `SNOWFLAKE`: SNOWFLAKE
    """

    __schema__ = schema
    __choices__ = (
        "AWS",
        "AWS_GENERIC",
        "AWS_PROXIED",
        "AZURE",
        "GCP",
        "GCP_PROXIED",
        "GENERIC",
        "SNOWFLAKE",
    )


class AgentModelStorageType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AZURE_BLOB`: Azure Storage
    * `GCS`: Google Cloud Storage
    * `S3`: Amazon S3
    * `S3_COMPATIBLE`: S3 Compatible Storage
    * `SNOWFLAKE_INTERNAL_STAGE`: Snowflake Internal Stage
    """

    __schema__ = schema
    __choices__ = ("AZURE_BLOB", "GCS", "S3", "S3_COMPATIBLE", "SNOWFLAKE_INTERNAL_STAGE")


class AgentModelWrapperType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CLOUDFORMATION`: CloudFormation
    * `GENERIC`: Generic Container
    * `KUBERNETES`: Kubernetes Cluster
    * `SNA_CONTAINER`: Snowflake Application Container
    * `TERRAFORM`: Terraform
    """

    __schema__ = schema
    __choices__ = ("CLOUDFORMATION", "GENERIC", "KUBERNETES", "SNA_CONTAINER", "TERRAFORM")


class AgentMonitorSelectExpressionType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALL`None
    * `EVALUATION`None
    * `SPAN_TREE`None
    * `SPAN_VIEW`None
    """

    __schema__ = schema
    __choices__ = ("ALL", "EVALUATION", "SPAN_TREE", "SPAN_VIEW")


class AgentTraceFormatEnum(sgqlc.types.Enum):
    """Enum for agent trace format types.

    Enumeration Choices:

    * `STANDARD`None
    * `STRANDS`None
    """

    __schema__ = schema
    __choices__ = ("STANDARD", "STRANDS")


class AgentTraceTableModelSpanFormat(sgqlc.types.Enum):
    """Enumeration Choices:

    * `STANDARD`: standard
    * `STRANDS`: strands
    """

    __schema__ = schema
    __choices__ = ("STANDARD", "STRANDS")


class AgentTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DATA_STORE_AGENT`None
    * `REMOTE_AGENT`None
    """

    __schema__ = schema
    __choices__ = ("DATA_STORE_AGENT", "REMOTE_AGENT")


class AggregateMetricType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `MAX`None
    * `MEAN`None
    * `MIN`None
    * `NULL_COUNT`None
    * `NULL_RATE`None
    * `ROW_COUNT`None
    * `STDDEV`None
    * `UNIQUENESS_COUNT`None
    * `UNIQUENESS_RATE`None
    """

    __schema__ = schema
    __choices__ = (
        "MAX",
        "MEAN",
        "MIN",
        "NULL_COUNT",
        "NULL_RATE",
        "ROW_COUNT",
        "STDDEV",
        "UNIQUENESS_COUNT",
        "UNIQUENESS_RATE",
    )


class AggregationFunction(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AVG`None
    * `MAX`None
    * `MEDIAN`None
    * `MIN`None
    """

    __schema__ = schema
    __choices__ = ("AVG", "MAX", "MEDIAN", "MIN")


class AiAgentType(sgqlc.types.Enum):
    """Types of AI agents available in the system.

    Enumeration Choices:

    * `TROUBLESHOOTING`None
    """

    __schema__ = schema
    __choices__ = ("TROUBLESHOOTING",)


class AirflowRunState(sgqlc.types.Enum):
    """Enumeration Choices:

    * `deferred`None
    * `failed`None
    * `queued`None
    * `removed`None
    * `restarting`None
    * `running`None
    * `scheduled`None
    * `skipped`None
    * `success`None
    * `unknown`None
    * `up_for_reschedule`None
    * `up_for_retry`None
    * `upstream_failed`None
    """

    __schema__ = schema
    __choices__ = (
        "deferred",
        "failed",
        "queued",
        "removed",
        "restarting",
        "running",
        "scheduled",
        "skipped",
        "success",
        "unknown",
        "up_for_reschedule",
        "up_for_retry",
        "upstream_failed",
    )


class AlertAccessRequestStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXPIRED`None
    * `NOTIFIED`None
    * `PENDING`None
    * `RESOLVED`None
    """

    __schema__ = schema
    __choices__ = ("EXPIRED", "NOTIFIED", "PENDING", "RESOLVED")


class AlertGroupBy(sgqlc.types.Enum):
    """Enumeration Choices:

    * `STATUS`None
    * `TYPE`None
    """

    __schema__ = schema
    __choices__ = ("STATUS", "TYPE")


class AlertReactionReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DETECTOR_TOO_SENSITIVE`None
    * `DONT_CARE_ABOUT_THIS_TABLE`None
    * `SEEN_THIS_TOO_MANY_TIMES`None
    """

    __schema__ = schema
    __choices__ = (
        "DETECTOR_TOO_SENSITIVE",
        "DONT_CARE_ABOUT_THIS_TABLE",
        "SEEN_THIS_TOO_MANY_TIMES",
    )


class AlertReactionType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `HELPFUL`None
    * `NOT_HELPFUL`None
    """

    __schema__ = schema
    __choices__ = ("HELPFUL", "NOT_HELPFUL")


class AlertStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACKNOWLEDGED`None
    * `EXPECTED`None
    * `FALSE_POSITIVE`None
    * `FIXED`None
    * `NO_ACTION_NEEDED`None
    * `WORK_IN_PROGRESS`None
    """

    __schema__ = schema
    __choices__ = (
        "ACKNOWLEDGED",
        "EXPECTED",
        "FALSE_POSITIVE",
        "FIXED",
        "NO_ACTION_NEEDED",
        "WORK_IN_PROGRESS",
    )


class AlertStatusInput(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACKNOWLEDGED`None
    * `EXPECTED`None
    * `FALSE_POSITIVE`None
    * `FIXED`None
    * `NO_ACTION_NEEDED`None
    * `NO_STATUS`None
    * `WORK_IN_PROGRESS`None
    """

    __schema__ = schema
    __choices__ = (
        "ACKNOWLEDGED",
        "EXPECTED",
        "FALSE_POSITIVE",
        "FIXED",
        "NO_ACTION_NEEDED",
        "NO_STATUS",
        "WORK_IN_PROGRESS",
    )


class AlertSubType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ADF_JOB_FAILURE`None
    * `AGENT_ANOMALIES`None
    * `AGENT_ANOMALY`None
    * `AIRFLOW_DAG_FAILURE`None
    * `ANOMALIES`None
    * `COMPARISON_RULE_BREACH`None
    * `CUSTOM_RULE_ANOMALIES`None
    * `DATABRICKS_JOB_FAILURE`None
    * `DBT_ERRORS`None
    * `DBT_MODEL_ERROR`None
    * `DBT_SEED_ERROR`None
    * `DBT_SNAPSHOT_ERROR`None
    * `DBT_TEST_FAILURE`None
    * `DBT_TEST_WARNING`None
    * `DELETED_TABLES`None
    * `DIMENSION_ANOMALY`None
    * `ETL_ERRORS`None
    * `FIELD_METRICS_ANOMALY`None
    * `FIELD_QUALITY_RULE_BREACH`None
    * `FRESHNESS_ANOMALY`None
    * `FRESHNESS_SLI_RULE_BREACH`None
    * `JSON_SCHEMA_ANOMALY_FIELDS_ADDED`None
    * `JSON_SCHEMA_ANOMALY_FIELDS_REMOVED`None
    * `JSON_SCHEMA_CHANGES`None
    * `JSON_SCHEMA_RULE_BREACH`None
    * `MERGED`None
    * `METRIC_ANOMALIES`None
    * `METRIC_COMPARISON_ANOMALIES`None
    * `METRIC_COMPARISON_ANOMALY`None
    * `PERFORMANCE_ANOMALIES`None
    * `PERFORMANCE_ANOMALY`None
    * `PSEUDO_INTEGRATION_TEST`None
    * `RULE_RUN_EXECUTION_ERROR`None
    * `SCHEMA_ANOMALY_FIELDS_ADDED`None
    * `SCHEMA_ANOMALY_FIELDS_CHANGED`None
    * `SCHEMA_ANOMALY_FIELDS_REMOVED`None
    * `SCHEMA_CHANGES`None
    * `SQL_RULE_BREACH`None
    * `VALIDATION_BREACH`None
    * `VOLUME_ANOMALY`None
    * `VOLUME_ANOMALY_ABNORMAL_SIZE_CHANGE`None
    * `VOLUME_ANOMALY_DATA_ADDED`None
    * `VOLUME_ANOMALY_DATA_REMOVED`None
    * `VOLUME_ANOMALY_UNCHANGED_SIZE`None
    * `VOLUME_SLI_RULE_BREACH`None
    """

    __schema__ = schema
    __choices__ = (
        "ADF_JOB_FAILURE",
        "AGENT_ANOMALIES",
        "AGENT_ANOMALY",
        "AIRFLOW_DAG_FAILURE",
        "ANOMALIES",
        "COMPARISON_RULE_BREACH",
        "CUSTOM_RULE_ANOMALIES",
        "DATABRICKS_JOB_FAILURE",
        "DBT_ERRORS",
        "DBT_MODEL_ERROR",
        "DBT_SEED_ERROR",
        "DBT_SNAPSHOT_ERROR",
        "DBT_TEST_FAILURE",
        "DBT_TEST_WARNING",
        "DELETED_TABLES",
        "DIMENSION_ANOMALY",
        "ETL_ERRORS",
        "FIELD_METRICS_ANOMALY",
        "FIELD_QUALITY_RULE_BREACH",
        "FRESHNESS_ANOMALY",
        "FRESHNESS_SLI_RULE_BREACH",
        "JSON_SCHEMA_ANOMALY_FIELDS_ADDED",
        "JSON_SCHEMA_ANOMALY_FIELDS_REMOVED",
        "JSON_SCHEMA_CHANGES",
        "JSON_SCHEMA_RULE_BREACH",
        "MERGED",
        "METRIC_ANOMALIES",
        "METRIC_COMPARISON_ANOMALIES",
        "METRIC_COMPARISON_ANOMALY",
        "PERFORMANCE_ANOMALIES",
        "PERFORMANCE_ANOMALY",
        "PSEUDO_INTEGRATION_TEST",
        "RULE_RUN_EXECUTION_ERROR",
        "SCHEMA_ANOMALY_FIELDS_ADDED",
        "SCHEMA_ANOMALY_FIELDS_CHANGED",
        "SCHEMA_ANOMALY_FIELDS_REMOVED",
        "SCHEMA_CHANGES",
        "SQL_RULE_BREACH",
        "VALIDATION_BREACH",
        "VOLUME_ANOMALY",
        "VOLUME_ANOMALY_ABNORMAL_SIZE_CHANGE",
        "VOLUME_ANOMALY_DATA_ADDED",
        "VOLUME_ANOMALY_DATA_REMOVED",
        "VOLUME_ANOMALY_UNCHANGED_SIZE",
        "VOLUME_SLI_RULE_BREACH",
    )


class AlertType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT_ANOMALIES`None
    * `ANOMALIES`None
    * `CUSTOM_RULE_ANOMALIES`None
    * `DBT_ERRORS`None
    * `DELETED_TABLES`None
    * `ETL_ERRORS`None
    * `JSON_SCHEMA_CHANGES`None
    * `MERGED`None
    * `METRIC_ANOMALIES`None
    * `METRIC_COMPARISON_ANOMALIES`None
    * `PERFORMANCE_ANOMALIES`None
    * `PSEUDO_INTEGRATION_TEST`None
    * `RULE_RUN_EXECUTION_ERROR`None
    * `SCHEMA_CHANGES`None
    """

    __schema__ = schema
    __choices__ = (
        "AGENT_ANOMALIES",
        "ANOMALIES",
        "CUSTOM_RULE_ANOMALIES",
        "DBT_ERRORS",
        "DELETED_TABLES",
        "ETL_ERRORS",
        "JSON_SCHEMA_CHANGES",
        "MERGED",
        "METRIC_ANOMALIES",
        "METRIC_COMPARISON_ANOMALIES",
        "PERFORMANCE_ANOMALIES",
        "PSEUDO_INTEGRATION_TEST",
        "RULE_RUN_EXECUTION_ERROR",
        "SCHEMA_CHANGES",
    )


class AlertsFilterFieldName(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AUDIENCE`None
    * `DATABASE`None
    * `DOMAIN`None
    * `HAS_AZURE_DEVOPS_WORK_ITEMS`None
    * `HAS_DATADOG_INCIDENTS`None
    * `HAS_JIRA_TICKETS`None
    * `HAS_KEY_ASSETS`None
    * `HAS_OPSGENIE_INCIDENTS`None
    * `HAS_SERVICE_NOW_INCIDENTS`None
    * `IS_NORMALIZED`None
    * `MONITOR_TAG`None
    * `OWNER`None
    * `PRIORITY`None
    * `SCHEMA`None
    * `SEVERITY`None
    * `STATUS`None
    * `TABLE`None
    * `TAG`None
    * `TYPE`None
    """

    __schema__ = schema
    __choices__ = (
        "AUDIENCE",
        "DATABASE",
        "DOMAIN",
        "HAS_AZURE_DEVOPS_WORK_ITEMS",
        "HAS_DATADOG_INCIDENTS",
        "HAS_JIRA_TICKETS",
        "HAS_KEY_ASSETS",
        "HAS_OPSGENIE_INCIDENTS",
        "HAS_SERVICE_NOW_INCIDENTS",
        "IS_NORMALIZED",
        "MONITOR_TAG",
        "OWNER",
        "PRIORITY",
        "SCHEMA",
        "SEVERITY",
        "STATUS",
        "TABLE",
        "TAG",
        "TYPE",
    )


class AssetCollectionRuleEffect(sgqlc.types.Enum):
    """Enumeration Choices:

    * `allow`None
    * `block`None
    """

    __schema__ = schema
    __choices__ = ("allow", "block")


class AssetFilterTableNameOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CONTAINS`None
    * `ENDS_WITH`None
    * `MATCH_PATTERN`None
    * `STARTS_WITH`None
    """

    __schema__ = schema
    __choices__ = ("CONTAINS", "ENDS_WITH", "MATCH_PATTERN", "STARTS_WITH")


class AssetFilterTableTagOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `HAS_ALL`None
    * `HAS_ANY`None
    """

    __schema__ = schema
    __choices__ = ("HAS_ALL", "HAS_ANY")


class AssetFilterType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACTIVITY_READ`None
    * `ACTIVITY_READ_IS_NULL`None
    * `ACTIVITY_READ_WRITE`None
    * `ACTIVITY_READ_WRITE_IS_NULL`None
    * `ACTIVITY_VOLUME_CHANGE`None
    * `ACTIVITY_WRITE`None
    * `ACTIVITY_WRITE_IS_NULL`None
    * `TABLE_NAME`None
    * `TABLE_TAG`None
    * `TABLE_TYPE`None
    """

    __schema__ = schema
    __choices__ = (
        "ACTIVITY_READ",
        "ACTIVITY_READ_IS_NULL",
        "ACTIVITY_READ_WRITE",
        "ACTIVITY_READ_WRITE_IS_NULL",
        "ACTIVITY_VOLUME_CHANGE",
        "ACTIVITY_WRITE",
        "ACTIVITY_WRITE_IS_NULL",
        "TABLE_NAME",
        "TABLE_TAG",
        "TABLE_TYPE",
    )


class AssetSelectionLevel(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DATABASE`None
    * `SCHEMA`None
    * `TABLE`None
    * `WAREHOUSE`None
    """

    __schema__ = schema
    __choices__ = ("DATABASE", "SCHEMA", "TABLE", "WAREHOUSE")


class AssetsSortDirection(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ASC`None
    * `DESC`None
    """

    __schema__ = schema
    __choices__ = ("ASC", "DESC")


class AuthType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BASIC`None
    * `BEARER`None
    * `NO_AUTH`None
    """

    __schema__ = schema
    __choices__ = ("BASIC", "BEARER", "NO_AUTH")


class AuthTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AWS_ASSUMABLE_ROLE`None
    * `AWS_IAM_AUTH`None
    * `AWS_VPCE`None
    * `AZURE_FUNCTION_APP_KEY`None
    * `AZURE_STORAGE_ACCOUNT_KEYS`None
    * `GCP_JSON_SERVICE_ACCOUNT_KEY`None
    * `GCP_WORKLOAD_IDENTITY_FEDERATION`None
    * `MCD_SHA512`None
    * `OAUTH2_CLIENT_CREDENTIALS`None
    * `OAUTH2_PASSWORD`None
    """

    __schema__ = schema
    __choices__ = (
        "AWS_ASSUMABLE_ROLE",
        "AWS_IAM_AUTH",
        "AWS_VPCE",
        "AZURE_FUNCTION_APP_KEY",
        "AZURE_STORAGE_ACCOUNT_KEYS",
        "GCP_JSON_SERVICE_ACCOUNT_KEY",
        "GCP_WORKLOAD_IDENTITY_FEDERATION",
        "MCD_SHA512",
        "OAUTH2_CLIENT_CREDENTIALS",
        "OAUTH2_PASSWORD",
    )


class AuthorizationGroupSource(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AUTHORIZATION_PROVIDER`: Group is automatically created/managed
      from the account's auth provider via a protocol such as SCIM.
    * `BUILT_IN`: Group is automatically provided and managed by Monte
      Carlo for all customers.
    * `CUSTOM`: Group is defined and managed by the account either
      through the Admin UI or APIs.
    """

    __schema__ = schema
    __choices__ = ("AUTHORIZATION_PROVIDER", "BUILT_IN", "CUSTOM")


class AutoOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AUTO`None
    * `AUTO_HIGH`None
    * `AUTO_LOW`None
    """

    __schema__ = schema
    __choices__ = ("AUTO", "AUTO_HIGH", "AUTO_LOW")


class AwsEnvConfiguration(sgqlc.types.Enum):
    """Enumeration Choices:

    * `primary`None
    * `secondary`None
    """

    __schema__ = schema
    __choices__ = ("primary", "secondary")


class BiContainerModelType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `LOOKER`: Looker
    * `POWER_BI`: Power BI
    * `TABLEAU`: Tableau
    """

    __schema__ = schema
    __choices__ = ("LOOKER", "POWER_BI", "TABLEAU")


class BigInt(sgqlc.types.Scalar):
    """BigInt is an extension of the regular Int field     that supports
    Integers bigger than a signed     32-bit integer.  Copied from
    https://stackoverflow.com/questions/45624042/graphene-django-
    converts-models-biginteger-to-graphene-integer Current graphene:
    https://github.com/graphql-
    python/graphene/blob/master/graphene/types/scalars.py#L88
    """

    __schema__ = schema


class BillingInvoiceStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DRAFT`None
    * `FINALIZED`None
    * `VOID`None
    """

    __schema__ = schema
    __choices__ = ("DRAFT", "FINALIZED", "VOID")


class BillingInvoicesSort(sgqlc.types.Enum):
    """Enumeration Choices:

    * `date_asc`None
    * `date_desc`None
    """

    __schema__ = schema
    __choices__ = ("date_asc", "date_desc")


class BillingPlanType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ENTERPRISE`None
    * `ENTERPRISE_WITH_ADVANCED_NETWORKING`None
    * `SCALE`None
    * `SCALE_WITH_ADVANCED_NETWORKING`None
    * `START`None
    """

    __schema__ = schema
    __choices__ = (
        "ENTERPRISE",
        "ENTERPRISE_WITH_ADVANCED_NETWORKING",
        "SCALE",
        "SCALE_WITH_ADVANCED_NETWORKING",
        "START",
    )


Boolean = sgqlc.types.Boolean


class BooleanOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AND`None
    * `OR`None
    """

    __schema__ = schema
    __choices__ = ("AND", "OR")


class CollectionNodeModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ASSIGNED`: Assigned
    * `AVAILABLE`: Available
    * `DELETED`: Deleted
    * `READY`: Ready
    * `UNASSIGNED`: Unassigned
    """

    __schema__ = schema
    __choices__ = ("ASSIGNED", "AVAILABLE", "DELETED", "READY", "UNASSIGNED")


class CollectionPreferenceEffectType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `allow`None
    * `block`None
    """

    __schema__ = schema
    __choices__ = ("allow", "block")


class CollectionPreferenceMatchType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `exact_match`None
    * `prefix`None
    * `regexp`None
    * `substring`None
    * `suffix`None
    """

    __schema__ = schema
    __choices__ = ("exact_match", "prefix", "regexp", "substring", "suffix")


class CollectionPreferenceTargetObjectType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `dataset`None
    * `project`None
    * `table`None
    """

    __schema__ = schema
    __choices__ = ("dataset", "project", "table")


class CollectionStorageModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ASSIGNED`: Assigned
    * `AVAILABLE`: Available
    * `DELETED`: Deleted
    * `READY`: Ready
    * `UNASSIGNED`: Unassigned
    """

    __schema__ = schema
    __choices__ = ("ASSIGNED", "AVAILABLE", "DELETED", "READY", "UNASSIGNED")


class ComparisonDataSourceType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `SOURCE`None
    * `TARGET`None
    """

    __schema__ = schema
    __choices__ = ("SOURCE", "TARGET")


class ComparisonType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ABSOLUTE_VOLUME`None
    * `CHANGE`None
    * `COMPARISON_DELTA`None
    * `DYNAMIC_THRESHOLD`None
    * `FRESHNESS`None
    * `GROWTH_VOLUME`None
    * `LOOKBACK`None
    * `QUERY_PERFORMANCE`None
    * `SOURCE_TARGET_DELTA`None
    * `THRESHOLD`None
    """

    __schema__ = schema
    __choices__ = (
        "ABSOLUTE_VOLUME",
        "CHANGE",
        "COMPARISON_DELTA",
        "DYNAMIC_THRESHOLD",
        "FRESHNESS",
        "GROWTH_VOLUME",
        "LOOKBACK",
        "QUERY_PERFORMANCE",
        "SOURCE_TARGET_DELTA",
        "THRESHOLD",
    )


class ConnectionModelType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AIRFLOW`: Airflow
    * `ATHENA`: Athena
    * `AZURE_DATA_FACTORY`: Azure Data Factory
    * `BIGQUERY`: BigQuery
    * `CLICKHOUSE`: ClickHouse
    * `CONFLUENT_KAFKA`: Confluent Kafka
    * `CONFLUENT_KAFKA_CONNECT`: Confluent Kafka Connect
    * `DATABRICKS_METASTORE_SQL_WAREHOUSE`: Databricks Metastore Sql
      Warehouse
    * `DATABRICKS_SQL_WAREHOUSE`: Databricks Sql Warehouse
    * `DB2`: Db2
    * `DBT_CLOUD`: dbt Cloud
    * `DBT_CLOUD_V2`: dbt Cloud v2
    * `DBT_CLOUD_WEBHOOK`: dbt Cloud Webhook
    * `DBT_CORE`: dbt Core
    * `DREMIO`: dremio
    * `FIVETRAN`: Fivetran
    * `GLUE`: Glue
    * `HIVE`: Hive
    * `HIVE_MYSQL`: Hive (MySQL)
    * `HIVE_S3`: Hive (S3 Location)
    * `INFORMATICA`: Informatica
    * `LOOKER`: Looker
    * `LOOKER_GIT`: Looker Git
    * `LOOKER_GIT_CLONE`: Looker Git Clone either ssh or https
    * `LOOKER_GIT_SSH`: Looker Git SSH
    * `MSK_KAFKA`: MSK Kafka
    * `MSK_KAFKA_CONNECT`: MSK Kafka Connect
    * `MYSQL`: MySQL
    * `ORACLE`: Oracle
    * `PINECONE`: Pinecone
    * `POWER_BI`: Power BI
    * `PRESTO`: Presto
    * `REDSHIFT`: Amazon Redshift
    * `S3`: S3
    * `S3_METADATA_EVENTS`: S3 Metadata Events
    * `S3_QL_EVENTS`: S3 Query Log Events
    * `SALESFORCE_CRM`: Salesforce CRM
    * `SALESFORCE_DATA_CLOUD`: Salesforce Data Cloud
    * `SELF_HOSTED_KAFKA`: Self Hosted Kafka
    * `SELF_HOSTED_KAFKA_CONNECT`: Self Hosted Kafka Connect
    * `SNOWFLAKE`: Snowflake
    * `SPARK`: Spark
    * `STARBURST_ENTERPRISE`: Starburst Enterprise
    * `STARBURST_GALAXY`: Starburst Galaxy
    * `TABLEAU`: Tableau
    * `TERADATA`: teradata
    * `TRANSACTIONAL_DB`: transactional-db
    """

    __schema__ = schema
    __choices__ = (
        "AIRFLOW",
        "ATHENA",
        "AZURE_DATA_FACTORY",
        "BIGQUERY",
        "CLICKHOUSE",
        "CONFLUENT_KAFKA",
        "CONFLUENT_KAFKA_CONNECT",
        "DATABRICKS_METASTORE_SQL_WAREHOUSE",
        "DATABRICKS_SQL_WAREHOUSE",
        "DB2",
        "DBT_CLOUD",
        "DBT_CLOUD_V2",
        "DBT_CLOUD_WEBHOOK",
        "DBT_CORE",
        "DREMIO",
        "FIVETRAN",
        "GLUE",
        "HIVE",
        "HIVE_MYSQL",
        "HIVE_S3",
        "INFORMATICA",
        "LOOKER",
        "LOOKER_GIT",
        "LOOKER_GIT_CLONE",
        "LOOKER_GIT_SSH",
        "MSK_KAFKA",
        "MSK_KAFKA_CONNECT",
        "MYSQL",
        "ORACLE",
        "PINECONE",
        "POWER_BI",
        "PRESTO",
        "REDSHIFT",
        "S3",
        "S3_METADATA_EVENTS",
        "S3_QL_EVENTS",
        "SALESFORCE_CRM",
        "SALESFORCE_DATA_CLOUD",
        "SELF_HOSTED_KAFKA",
        "SELF_HOSTED_KAFKA_CONNECT",
        "SNOWFLAKE",
        "SPARK",
        "STARBURST_ENTERPRISE",
        "STARBURST_GALAXY",
        "TABLEAU",
        "TERADATA",
        "TRANSACTIONAL_DB",
    )


class ConnectionSubtypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AZURE_DEDICATED_SQL_POOL`None
    * `AZURE_SQL_DATABASE`None
    * `DB2`None
    * `MARIADB`None
    * `MOTHERDUCK`None
    * `MYSQL`None
    * `ORACLE`None
    * `POSTGRES`None
    * `SAP_HANA`None
    * `SQL_SERVER`None
    * `TERADATA`None
    """

    __schema__ = schema
    __choices__ = (
        "AZURE_DEDICATED_SQL_POOL",
        "AZURE_SQL_DATABASE",
        "DB2",
        "MARIADB",
        "MOTHERDUCK",
        "MYSQL",
        "ORACLE",
        "POSTGRES",
        "SAP_HANA",
        "SQL_SERVER",
        "TERADATA",
    )


class ConnectionTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AIRFLOW`None
    * `ATHENA`None
    * `AZURE_DATA_FACTORY`None
    * `BIGQUERY`None
    * `CLICKHOUSE`None
    * `CONFLUENT_KAFKA`None
    * `CONFLUENT_KAFKA_CONNECT`None
    * `DATABRICKS_METASTORE_SQL_WAREHOUSE`None
    * `DATABRICKS_SQL_WAREHOUSE`None
    * `DB2`None
    * `DBT_CLOUD`None
    * `DBT_CLOUD_V2`None
    * `DBT_CLOUD_WEBHOOK`None
    * `DBT_CORE`None
    * `DREMIO`None
    * `FIVETRAN`None
    * `GLUE`None
    * `HIVE`None
    * `HIVE_MYSQL`None
    * `HIVE_S3`None
    * `INFORMATICA`None
    * `LOOKER`None
    * `LOOKER_GIT`None
    * `LOOKER_GIT_CLONE`None
    * `LOOKER_GIT_SSH`None
    * `MSK_KAFKA`None
    * `MSK_KAFKA_CONNECT`None
    * `MYSQL`None
    * `ORACLE`None
    * `PINECONE`None
    * `POWER_BI`None
    * `PRESTO`None
    * `REDSHIFT`None
    * `S3`None
    * `S3_METADATA_EVENTS`None
    * `S3_QL_EVENTS`None
    * `SALESFORCE_CRM`None
    * `SALESFORCE_DATA_CLOUD`None
    * `SELF_HOSTED_KAFKA`None
    * `SELF_HOSTED_KAFKA_CONNECT`None
    * `SNOWFLAKE`None
    * `SPARK`None
    * `STARBURST_ENTERPRISE`None
    * `STARBURST_GALAXY`None
    * `TABLEAU`None
    * `TERADATA`None
    * `TRANSACTIONAL_DB`None
    """

    __schema__ = schema
    __choices__ = (
        "AIRFLOW",
        "ATHENA",
        "AZURE_DATA_FACTORY",
        "BIGQUERY",
        "CLICKHOUSE",
        "CONFLUENT_KAFKA",
        "CONFLUENT_KAFKA_CONNECT",
        "DATABRICKS_METASTORE_SQL_WAREHOUSE",
        "DATABRICKS_SQL_WAREHOUSE",
        "DB2",
        "DBT_CLOUD",
        "DBT_CLOUD_V2",
        "DBT_CLOUD_WEBHOOK",
        "DBT_CORE",
        "DREMIO",
        "FIVETRAN",
        "GLUE",
        "HIVE",
        "HIVE_MYSQL",
        "HIVE_S3",
        "INFORMATICA",
        "LOOKER",
        "LOOKER_GIT",
        "LOOKER_GIT_CLONE",
        "LOOKER_GIT_SSH",
        "MSK_KAFKA",
        "MSK_KAFKA_CONNECT",
        "MYSQL",
        "ORACLE",
        "PINECONE",
        "POWER_BI",
        "PRESTO",
        "REDSHIFT",
        "S3",
        "S3_METADATA_EVENTS",
        "S3_QL_EVENTS",
        "SALESFORCE_CRM",
        "SALESFORCE_DATA_CLOUD",
        "SELF_HOSTED_KAFKA",
        "SELF_HOSTED_KAFKA_CONNECT",
        "SNOWFLAKE",
        "SPARK",
        "STARBURST_ENTERPRISE",
        "STARBURST_GALAXY",
        "TABLEAU",
        "TERADATA",
        "TRANSACTIONAL_DB",
    )


class ConsolidatedMonitorStatusType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DISABLED`None
    * `DRAFT`None
    * `ENABLED`None
    * `ERROR`None
    * `INSUFFICIENT_DATA`None
    * `SNOOZED`None
    * `TRAINING`None
    """

    __schema__ = schema
    __choices__ = (
        "DISABLED",
        "DRAFT",
        "ENABLED",
        "ERROR",
        "INSUFFICIENT_DATA",
        "SNOOZED",
        "TRAINING",
    )


class CustomDashboardWidgetDataSourceType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `JOB_EXECUTIONS`None
    * `METRICS`None
    * `MONITOR`None
    """

    __schema__ = schema
    __choices__ = ("JOB_EXECUTIONS", "METRICS", "MONITOR")


class CustomDashboardWidgetType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `GRAPH`None
    * `SCALAR`None
    * `TABLE`None
    * `TEXT`None
    """

    __schema__ = schema
    __choices__ = ("GRAPH", "SCALAR", "TABLE", "TEXT")


class CustomRuleComparisonOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AUTO`None
    * `AUTO_HIGH`None
    * `AUTO_LOW`None
    * `EQ`None
    * `GT`None
    * `GTE`None
    * `INSIDE_RANGE`None
    * `IS_NOT_NULL`None
    * `IS_NULL`None
    * `LT`None
    * `LTE`None
    * `NEQ`None
    * `OUTSIDE_RANGE`None
    """

    __schema__ = schema
    __choices__ = (
        "AUTO",
        "AUTO_HIGH",
        "AUTO_LOW",
        "EQ",
        "GT",
        "GTE",
        "INSIDE_RANGE",
        "IS_NOT_NULL",
        "IS_NULL",
        "LT",
        "LTE",
        "NEQ",
        "OUTSIDE_RANGE",
    )


class CustomRuleModelQueryResultType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `LABELED_NUMERICS`: LABELED_NUMERICS
    * `ROWS`: ROWS
    * `ROW_COUNT`: ROW_COUNT
    * `SINGLE_NUMERIC`: SINGLE_NUMERIC
    * `UNIQUE_ROW_COUNT`: UNIQUE_ROW_COUNT
    * `UNIQUE_VALUE_LIST`: UNIQUE_VALUE_LIST
    * `VALUE_LIST`: VALUE_LIST
    """

    __schema__ = schema
    __choices__ = (
        "LABELED_NUMERICS",
        "ROWS",
        "ROW_COUNT",
        "SINGLE_NUMERIC",
        "UNIQUE_ROW_COUNT",
        "UNIQUE_VALUE_LIST",
        "VALUE_LIST",
    )


class CustomRuleModelRuleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPARISON`: Comparison
    * `CUSTOM_SQL`: Custom SQL
    * `FIELD_QUALITY`: Metric - legacy
    * `FRESHNESS`: Freshness
    * `QUERY_PERF`: Query performance
    * `TABLE_METRIC`: Table metric rule
    * `VALIDATION`: Validation
    * `VOLUME`: Volume
    """

    __schema__ = schema
    __choices__ = (
        "COMPARISON",
        "CUSTOM_SQL",
        "FIELD_QUALITY",
        "FRESHNESS",
        "QUERY_PERF",
        "TABLE_METRIC",
        "VALIDATION",
        "VOLUME",
    )


class CustomSQLTemplateModelQueryResultType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `LABELED_NUMERICS`: LABELED_NUMERICS
    * `ROWS`: ROWS
    * `ROW_COUNT`: ROW_COUNT
    * `SINGLE_NUMERIC`: SINGLE_NUMERIC
    * `UNIQUE_ROW_COUNT`: UNIQUE_ROW_COUNT
    * `UNIQUE_VALUE_LIST`: UNIQUE_VALUE_LIST
    * `VALUE_LIST`: VALUE_LIST
    """

    __schema__ = schema
    __choices__ = (
        "LABELED_NUMERICS",
        "ROWS",
        "ROW_COUNT",
        "SINGLE_NUMERIC",
        "UNIQUE_ROW_COUNT",
        "UNIQUE_VALUE_LIST",
        "VALUE_LIST",
    )


class DashboardType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `READ`None
    * `WRITE`None
    """

    __schema__ = schema
    __choices__ = ("READ", "WRITE")


class DataAssetTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ASSET_TYPE_EXTERNAL`None
    * `ASSET_TYPE_SNOWFLAKE_STREAM`None
    * `ASSET_TYPE_TABLE`None
    * `ASSET_TYPE_VIEW`None
    * `ASSET_TYPE_WILDCARD_TABLE`None
    """

    __schema__ = schema
    __choices__ = (
        "ASSET_TYPE_EXTERNAL",
        "ASSET_TYPE_SNOWFLAKE_STREAM",
        "ASSET_TYPE_TABLE",
        "ASSET_TYPE_VIEW",
        "ASSET_TYPE_WILDCARD_TABLE",
    )


class DataCollectorDeploymentTypeExtendedEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CLOUD_V1`None
    * `CLOUD_V2_M`None
    * `CLOUD_V2_P`None
    * `REMOTE_V1`None
    * `REMOTE_V1_5`None
    * `REMOTE_V2_EA`None
    * `REMOTE_V2_IA`None
    """

    __schema__ = schema
    __choices__ = (
        "CLOUD_V1",
        "CLOUD_V2_M",
        "CLOUD_V2_P",
        "REMOTE_V1",
        "REMOTE_V1_5",
        "REMOTE_V2_EA",
        "REMOTE_V2_IA",
    )


class DataCollectorEventTypes(sgqlc.types.Enum):
    """Enumeration Choices:

    * `s3_metadata_events`None
    * `s3_ql_events`None
    """

    __schema__ = schema
    __choices__ = ("s3_metadata_events", "s3_ql_events")


class DataCollectorModelDeploymentTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CLOUD_V1`None
    * `CLOUD_V2`None
    * `REMOTE_V1`None
    * `REMOTE_V1_5`None
    * `REMOTE_V2`None
    """

    __schema__ = schema
    __choices__ = ("CLOUD_V1", "CLOUD_V2", "REMOTE_V1", "REMOTE_V1_5", "REMOTE_V2")


class DataCollectorScheduleModelDeleteReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT_TRACE_TABLE_DELETED`: agent_trace_table_deleted
    * `CONNECTION_DELETED`: connection_deleted
    * `DEPRECATED_JOB_TYPE`: deprecated_job_type
    * `MONITOR_DELETED`: monitor_deleted
    * `NO_AGENT`: no_agent
    * `NO_COLLECTOR`: no_collector
    * `RULE_DELETED`: rule_deleted
    * `SIZE_COLLECTION_DISABLED`: size_collection_disabled
    """

    __schema__ = schema
    __choices__ = (
        "AGENT_TRACE_TABLE_DELETED",
        "CONNECTION_DELETED",
        "DEPRECATED_JOB_TYPE",
        "MONITOR_DELETED",
        "NO_AGENT",
        "NO_COLLECTOR",
        "RULE_DELETED",
        "SIZE_COLLECTION_DISABLED",
    )


class DataCollectorScheduleModelScheduleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DYNAMIC`: Dynamic
    * `FIXED`: Fixed
    * `LOOSE`: Loose
    * `MANUAL`: Manual
    """

    __schema__ = schema
    __choices__ = ("DYNAMIC", "FIXED", "LOOSE", "MANUAL")


class DataCollectorScheduleModelSkipReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `MANUALLY_SKIPPED`: Manually skipped
    * `NONE`: Empty reason
    """

    __schema__ = schema
    __choices__ = ("MANUALLY_SKIPPED", "NONE")


class DataColumnTypes(sgqlc.types.Enum):
    """Available types for column values.

    Enumeration Choices:

    * `CHART`None
    * `DATE_TIME`None
    * `HOURS`None
    * `NUMERIC`None
    * `PERCENTAGE`None
    * `TEXT`None
    """

    __schema__ = schema
    __choices__ = ("CHART", "DATE_TIME", "HOURS", "NUMERIC", "PERCENTAGE", "TEXT")


class DataExplorerWidgetModelWidgetType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DISCRETE`: DISCRETE
    * `FIELD_PROFILE_TABLE_V2`: FIELD_PROFILE_TABLE_V2
    * `NUMERIC_DESCRIPTIVE_STATS`: NUMERIC_DESCRIPTIVE_STATS
    * `TIMESTAMP_HISTOGRAM`: TIMESTAMP_HISTOGRAM
    """

    __schema__ = schema
    __choices__ = (
        "DISCRETE",
        "FIELD_PROFILE_TABLE_V2",
        "NUMERIC_DESCRIPTIVE_STATS",
        "TIMESTAMP_HISTOGRAM",
    )


class DataExportNames(sgqlc.types.Enum):
    """Available Data Exports.

    Enumeration Choices:

    * `ALERTS`: Export containing all alerts data in the past 90 days
    * `ALERTS_AND_EVENTS`: Export containing both alerts and events
      data
    * `ALL_MONITORS`: DEPRECATED
    * `ASSETS`: Export containing all assets data
    * `EVENTS`: Export containing all events data in the past 90 days
    * `LINEAGE_EDGES`: Export containing lineage edges data. (This
      report is not generally available.)
    * `MONITORS`: Export containing all monitors data
    """

    __schema__ = schema
    __choices__ = (
        "ALERTS",
        "ALERTS_AND_EVENTS",
        "ALL_MONITORS",
        "ASSETS",
        "EVENTS",
        "LINEAGE_EDGES",
        "MONITORS",
    )


class DataMaintenanceMetric(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALL`None
    * `DT_METRICS`None
    * `FH_METRICS`None
    * `FRESHNESS`None
    * `METRIC_MONITOR`None
    * `MONITOR`None
    * `UNCHANGED_SIZE`None
    * `VOLUME`None
    """

    __schema__ = schema
    __choices__ = (
        "ALL",
        "DT_METRICS",
        "FH_METRICS",
        "FRESHNESS",
        "METRIC_MONITOR",
        "MONITOR",
        "UNCHANGED_SIZE",
        "VOLUME",
    )


class DataMaintenanceReasonType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CUSTOM`None
    * `HOLIDAY`None
    * `TRAINING`None
    """

    __schema__ = schema
    __choices__ = ("CUSTOM", "HOLIDAY", "TRAINING")


class DataProductMetric(sgqlc.types.Enum):
    """Metrics for data products

    Enumeration Choices:

    * `INCIDENTS_BY_DAY`None
    * `INCIDENTS_BY_HOUR`None
    * `INCIDENTS_BY_PRIORITY`None
    * `INCIDENTS_BY_SEVERITY`None
    * `INCIDENTS_BY_STATUS`None
    * `INCIDENTS_STATUS_UPDATE_RATES_BY_DAY`None
    * `INCIDENTS_STATUS_UPDATE_RATES_BY_HOUR`None
    * `INCIDENTS_TIME_TO_FIXED_BY_DAY`None
    * `INCIDENTS_TIME_TO_FIXED_BY_HOUR`None
    * `INCIDENTS_TIME_TO_RESPONSE_BY_DAY`None
    * `INCIDENTS_TIME_TO_RESPONSE_BY_HOUR`None
    * `TABLE_UPTIME_FOR_AUTOMATED_FRESHNESS_MONITORS_BY_DAY`None
    * `TABLE_UPTIME_FOR_AUTOMATED_FRESHNESS_MONITORS_BY_HOUR`None
    * `TABLE_UPTIME_FOR_AUTOMATED_VOLUME_MONITORS_BY_DAY`None
    * `TABLE_UPTIME_FOR_AUTOMATED_VOLUME_MONITORS_BY_HOUR`None
    * `TABLE_UPTIME_FOR_CUSTOM_FRESHNESS_MONITORS_BY_DAY`None
    * `TABLE_UPTIME_FOR_CUSTOM_FRESHNESS_MONITORS_BY_HOUR`None
    * `TABLE_UPTIME_FOR_CUSTOM_SQL_MONITORS_BY_DAY`None
    * `TABLE_UPTIME_FOR_CUSTOM_SQL_MONITORS_BY_HOUR`None
    * `TABLE_UPTIME_FOR_CUSTOM_VOLUME_MONITORS_BY_DAY`None
    * `TABLE_UPTIME_FOR_CUSTOM_VOLUME_MONITORS_BY_HOUR`None
    * `TABLE_UPTIME_FOR_FIELD_HEALTH_MONITORS_BY_DAY`None
    * `TABLE_UPTIME_FOR_FIELD_HEALTH_MONITORS_BY_HOUR`None
    """

    __schema__ = schema
    __choices__ = (
        "INCIDENTS_BY_DAY",
        "INCIDENTS_BY_HOUR",
        "INCIDENTS_BY_PRIORITY",
        "INCIDENTS_BY_SEVERITY",
        "INCIDENTS_BY_STATUS",
        "INCIDENTS_STATUS_UPDATE_RATES_BY_DAY",
        "INCIDENTS_STATUS_UPDATE_RATES_BY_HOUR",
        "INCIDENTS_TIME_TO_FIXED_BY_DAY",
        "INCIDENTS_TIME_TO_FIXED_BY_HOUR",
        "INCIDENTS_TIME_TO_RESPONSE_BY_DAY",
        "INCIDENTS_TIME_TO_RESPONSE_BY_HOUR",
        "TABLE_UPTIME_FOR_AUTOMATED_FRESHNESS_MONITORS_BY_DAY",
        "TABLE_UPTIME_FOR_AUTOMATED_FRESHNESS_MONITORS_BY_HOUR",
        "TABLE_UPTIME_FOR_AUTOMATED_VOLUME_MONITORS_BY_DAY",
        "TABLE_UPTIME_FOR_AUTOMATED_VOLUME_MONITORS_BY_HOUR",
        "TABLE_UPTIME_FOR_CUSTOM_FRESHNESS_MONITORS_BY_DAY",
        "TABLE_UPTIME_FOR_CUSTOM_FRESHNESS_MONITORS_BY_HOUR",
        "TABLE_UPTIME_FOR_CUSTOM_SQL_MONITORS_BY_DAY",
        "TABLE_UPTIME_FOR_CUSTOM_SQL_MONITORS_BY_HOUR",
        "TABLE_UPTIME_FOR_CUSTOM_VOLUME_MONITORS_BY_DAY",
        "TABLE_UPTIME_FOR_CUSTOM_VOLUME_MONITORS_BY_HOUR",
        "TABLE_UPTIME_FOR_FIELD_HEALTH_MONITORS_BY_DAY",
        "TABLE_UPTIME_FOR_FIELD_HEALTH_MONITORS_BY_HOUR",
    )


class DataShareType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `SNOWFLAKE`None
    """

    __schema__ = schema
    __choices__ = ("SNOWFLAKE",)


class DataSourceType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `SQL`None
    * `TABLE`None
    """

    __schema__ = schema
    __choices__ = ("SQL", "TABLE")


class DatabricksJobRunModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BLOCKED`: BLOCKED
    * `CANCELLED`: CANCELLED
    * `ERROR`: ERROR
    * `FAILED`: FAILED
    * `SKIPPED`: SKIPPED
    * `SUCCEEDED`: SUCCEEDED
    * `TIMED_OUT`: TIMED_OUT
    """

    __schema__ = schema
    __choices__ = ("BLOCKED", "CANCELLED", "ERROR", "FAILED", "SKIPPED", "SUCCEEDED", "TIMED_OUT")


class DatabricksTaskRunModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BLOCKED`: BLOCKED
    * `CANCELLED`: CANCELLED
    * `ERROR`: ERROR
    * `FAILED`: FAILED
    * `SKIPPED`: SKIPPED
    * `SUCCEEDED`: SUCCEEDED
    * `TIMED_OUT`: TIMED_OUT
    """

    __schema__ = schema
    __choices__ = ("BLOCKED", "CANCELLED", "ERROR", "FAILED", "SKIPPED", "SUCCEEDED", "TIMED_OUT")


Date = sgqlc.types.datetime.Date

DateTime = sgqlc.types.datetime.DateTime


class DbtJobExecutionStatuses(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CANCELLED`None
    * `ERROR`None
    * `FAILED`None
    * `RUNNING`None
    * `SUCCESS`None
    """

    __schema__ = schema
    __choices__ = ("CANCELLED", "ERROR", "FAILED", "RUNNING", "SUCCESS")


class DbtProjectModelSource(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CLI`: CLI
    * `DBT_CLOUD`: dbt Cloud
    * `DBT_CORE`: dbt Core
    """

    __schema__ = schema
    __choices__ = ("CLI", "DBT_CLOUD", "DBT_CORE")


class DecryptionServiceTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `KMS`None
    """

    __schema__ = schema
    __choices__ = ("KMS",)


class DecryptionServiceUpdateTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `KMS`None
    """

    __schema__ = schema
    __choices__ = ("KMS",)


class DenialReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ENTITLEMENTS`None
    * `INVALID_USER`None
    * `TROUBLESHOOTING_AGENT_OFF`None
    * `TSA_FEATURE_FLAG_OFF`None
    """

    __schema__ = schema
    __choices__ = (
        "ENTITLEMENTS",
        "INVALID_USER",
        "TROUBLESHOOTING_AGENT_OFF",
        "TSA_FEATURE_FLAG_OFF",
    )


class DetectorStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACTIVE`None
    * `INACTIVE`None
    * `TRAINING`None
    """

    __schema__ = schema
    __choices__ = ("ACTIVE", "INACTIVE", "TRAINING")


class ETLAssetType(sgqlc.types.Enum):
    """Enum to distinguish between jobs and tasks

    Enumeration Choices:

    * `JOB`None
    * `TASK`None
    """

    __schema__ = schema
    __choices__ = ("JOB", "TASK")


class EdgeType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `IS_DOWNSTREAM`None
    * `IS_READ_BY`None
    * `MODIFIES`None
    """

    __schema__ = schema
    __choices__ = ("IS_DOWNSTREAM", "IS_READ_BY", "MODIFIES")


class EntitlementLimits(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DAILY_API_CALLS`None
    * `DATA_PRODUCTS`None
    * `DOMAINS`None
    * `MONITORED_TABLES`None
    * `USERS`None
    """

    __schema__ = schema
    __choices__ = ("DAILY_API_CALLS", "DATA_PRODUCTS", "DOMAINS", "MONITORED_TABLES", "USERS")


class EntitlementTypes(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ADVANCED_NETWORKING`None
    * `ADVANCED_SECURITY`None
    * `ADVANCED_SECURITY_V1_2`None
    * `API_CALLS`None
    * `AUDIT_LOGGING`None
    * `AUTH_GROUP_CONNECTION_RESTRICTION`None
    * `DATA_LAKES`None
    * `DATA_MESH`None
    * `EDW`None
    * `ENTERPRISE_PRODUCTIVITY`None
    * `ENTERPRISE_SUPPORT`None
    * `GEN_AI_PIPELINES`None
    * `INGESTED_TABLES`None
    * `MONITORED_TABLES`None
    * `MULTI_WORKSPACE`None
    * `SSO`None
    * `TRANSACTIONAL_DATABASES`None
    * `USERS`None
    """

    __schema__ = schema
    __choices__ = (
        "ADVANCED_NETWORKING",
        "ADVANCED_SECURITY",
        "ADVANCED_SECURITY_V1_2",
        "API_CALLS",
        "AUDIT_LOGGING",
        "AUTH_GROUP_CONNECTION_RESTRICTION",
        "DATA_LAKES",
        "DATA_MESH",
        "EDW",
        "ENTERPRISE_PRODUCTIVITY",
        "ENTERPRISE_SUPPORT",
        "GEN_AI_PIPELINES",
        "INGESTED_TABLES",
        "MONITORED_TABLES",
        "MULTI_WORKSPACE",
        "SSO",
        "TRANSACTIONAL_DATABASES",
        "USERS",
    )


class EtlDurationTrendIssue(sgqlc.types.Enum):
    """Represents potential reasons why the duration trend cannot be
    calculated.

    Enumeration Choices:

    * `NO_SUCCESS_RUNS_LAST_7_DAYS`: No successful completed runs in
      the last 7 days
    * `NO_SUCCESS_RUNS_PREVIOUS_7_DAYS`: No successful completed runs
      in the 7 days prior to the last 7 days
    * `ZERO_DURATION_LAST_7_DAYS`: All successful completed runs in
      the last 7 days have zero duration
    """

    __schema__ = schema
    __choices__ = (
        "NO_SUCCESS_RUNS_LAST_7_DAYS",
        "NO_SUCCESS_RUNS_PREVIOUS_7_DAYS",
        "ZERO_DURATION_LAST_7_DAYS",
    )


class EtlPerformanceSortDirection(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ASC`None
    * `DESC`None
    """

    __schema__ = schema
    __choices__ = ("ASC", "DESC")


class EtlRunStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BLOCKED`None
    * `CANCELLED`None
    * `CANCELLING`None
    * `DEFERRED`None
    * `ERROR`None
    * `FAIL`None
    * `FAILED`None
    * `INACTIVE`None
    * `IN_PROGRESS`None
    * `PARTIAL_SUCCESS`None
    * `PASS`None
    * `QUEUED`None
    * `REMOVED`None
    * `RESTARTING`None
    * `SCHEDULED`None
    * `SKIPPED`None
    * `SUCCESS`None
    * `TIMED_OUT`None
    * `UNKNOWN`None
    * `UPSTREAM_FAILED`None
    * `UP_FOR_RESCHEDULE`None
    * `UP_FOR_RETRY`None
    * `WARN`None
    """

    __schema__ = schema
    __choices__ = (
        "BLOCKED",
        "CANCELLED",
        "CANCELLING",
        "DEFERRED",
        "ERROR",
        "FAIL",
        "FAILED",
        "INACTIVE",
        "IN_PROGRESS",
        "PARTIAL_SUCCESS",
        "PASS",
        "QUEUED",
        "REMOVED",
        "RESTARTING",
        "SCHEDULED",
        "SKIPPED",
        "SUCCESS",
        "TIMED_OUT",
        "UNKNOWN",
        "UPSTREAM_FAILED",
        "UP_FOR_RESCHEDULE",
        "UP_FOR_RETRY",
        "WARN",
    )


class EtlType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AIRFLOW`None
    * `AZURE_DATA_FACTORY`None
    * `DATABRICKS`None
    * `DBT`None
    * `FIVETRAN`None
    * `INFORMATICA`None
    """

    __schema__ = schema
    __choices__ = ("AIRFLOW", "AZURE_DATA_FACTORY", "DATABRICKS", "DBT", "FIVETRAN", "INFORMATICA")


class EventModelEventState(sgqlc.types.Enum):
    """Enumeration Choices:

    * `FALSE_POSITIVE`: FALSE POSITIVE
    * `MUTED`: MUTED
    * `NOTIFIED`: NOTIFIED
    * `NO_ACTION_REQUIRED`: NO ACTION REQUIRED
    * `OPEN`: OPEN
    * `RESOLVED`: RESOLVED
    * `STALE`: STALE
    * `SYSTEM_RESOLVED`: RESOLVED
    * `TIMELINE`: Timeline event status
    * `USER_RESOLVED`: RESOLVED
    """

    __schema__ = schema
    __choices__ = (
        "FALSE_POSITIVE",
        "MUTED",
        "NOTIFIED",
        "NO_ACTION_REQUIRED",
        "OPEN",
        "RESOLVED",
        "STALE",
        "SYSTEM_RESOLVED",
        "TIMELINE",
        "USER_RESOLVED",
    )


class EventModelEventType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ADF_JOB_FAILURE`: Data Factory Pipeline Failure
    * `AGENT_ANOM`: Agent Anomaly
    * `AIRFLOW_DAG_FAILURE`: Airflow DAG Failure
    * `COMMENT`: Timeline Comment
    * `COMPARISON_RULE_ANOM`: Comparison Rule Anomaly
    * `CUSTOM_RULE_ANOM`: Custom Rule Anomaly
    * `DATABRICKS_JOB_FAILURE`: Databricks Job Failure
    * `DBT_MODEL_ERROR`: dbt Model Error
    * `DBT_SEED_ERROR`: dbt Seed Error
    * `DBT_SNAPSHOT_ERROR`: dbt Snapshot Error
    * `DBT_TEST_FAILURE`: dbt Test Failure
    * `DBT_TEST_WARNING`: dbt Test Warning
    * `DECLARED_INCIDENT_SEVERITY_UPDATE`: Incident Severity Update
    * `DELETE_TABLE`: Delete Table
    * `DIST_ANOM`: Distribution Anomaly
    * `FRESH_ANOM`: Freshness Anomaly
    * `INACTIVE_MONITOR`: Inactive Monitor
    * `INCIDENT_DETECTOR_FEEDBACK`: Detector Feedback
    * `INCIDENT_MERGE`: Incident Merge
    * `INCIDENT_NAME_UPDATE`: Incident Name Update
    * `INCIDENT_OWNER_UPDATE`: Incident Owner Update
    * `INCIDENT_REACTION`: Incident Reaction
    * `INCIDENT_SEVERITY_UPDATE`: Incident Severity Update
    * `INCIDENT_SLACK_THREAD`: Incident Slack Thread
    * `INCIDENT_SPLIT`: Incident Split
    * `INCIDENT_STATUS_UPDATE`: Incident Status Update
    * `JSON_SCHEMA_CHANGE`: JSON Schema Change
    * `METRIC_ANOM`: Metric Anomaly
    * `METRIC_COMPARISON_ANOM`: Metric Comparison Anomaly
    * `QUERY_PERFORMANCE_ANOM`: Query Performance Anomaly
    * `QUERY_RUNTIME_ANOM`: Query Runtime Anomaly
    * `RULE_RUN_FAILURE`: Rule Run Failure
    * `SCHEMA_CHANGE`: Schema Change
    * `SIZE_ANOM`: Size Anomaly
    * `SIZE_DIFF`: Row count anomaly
    * `UNCHANGED_SIZE_ANOM`: Unchanged Size Anomaly
    * `VALIDATION_ANOM`: Validation Anomaly
    """

    __schema__ = schema
    __choices__ = (
        "ADF_JOB_FAILURE",
        "AGENT_ANOM",
        "AIRFLOW_DAG_FAILURE",
        "COMMENT",
        "COMPARISON_RULE_ANOM",
        "CUSTOM_RULE_ANOM",
        "DATABRICKS_JOB_FAILURE",
        "DBT_MODEL_ERROR",
        "DBT_SEED_ERROR",
        "DBT_SNAPSHOT_ERROR",
        "DBT_TEST_FAILURE",
        "DBT_TEST_WARNING",
        "DECLARED_INCIDENT_SEVERITY_UPDATE",
        "DELETE_TABLE",
        "DIST_ANOM",
        "FRESH_ANOM",
        "INACTIVE_MONITOR",
        "INCIDENT_DETECTOR_FEEDBACK",
        "INCIDENT_MERGE",
        "INCIDENT_NAME_UPDATE",
        "INCIDENT_OWNER_UPDATE",
        "INCIDENT_REACTION",
        "INCIDENT_SEVERITY_UPDATE",
        "INCIDENT_SLACK_THREAD",
        "INCIDENT_SPLIT",
        "INCIDENT_STATUS_UPDATE",
        "JSON_SCHEMA_CHANGE",
        "METRIC_ANOM",
        "METRIC_COMPARISON_ANOM",
        "QUERY_PERFORMANCE_ANOM",
        "QUERY_RUNTIME_ANOM",
        "RULE_RUN_FAILURE",
        "SCHEMA_CHANGE",
        "SIZE_ANOM",
        "SIZE_DIFF",
        "UNCHANGED_SIZE_ANOM",
        "VALIDATION_ANOM",
    )


class EventMutingRuleModelRuleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXACT_MATCH_RULE`None
    * `REGEX_RULE`None
    """

    __schema__ = schema
    __choices__ = ("EXACT_MATCH_RULE", "REGEX_RULE")


class EventRcaStatusModelReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BAD_METRIC_EXPRESSION`: Bad metric expression
    * `BAD_RULE_CONFIGURATION`: Mostly for MaC monitors which where
      configured incorrectly
    * `BASELINE_SAMPLE_INSUFFICIENT`: Baseline sample too small to run
      analysis.
    * `BREACHES_SAMPLE_INSUFFICIENT`: Breaches sample too small to run
      analysis.
    * `CONNECTION_NOT_SUPPORTED`: Connection not supported
    * `DATA_SAMPLING_DISABLED`: Data Sampling disabled for warehouse
    * `DOES_NOT_MEET_CRITERIA`: Does not meet criteria
    * `DUPLICATE_EVENT`: Equivalent event already processed
    * `EVENT_MISSING_INCIDENT`: Event missing incident
    * `EVENT_MISSING_TABLE`: Event missing associated table
    * `HIGH_BREACHING_MONITOR`: Do not create RCAs for high breaching
      monitors
    * `MISSING_EVENT_WAREHOUSE`: Missing event warehouse connection.
    * `NOT_ENOUGH_BREACHES_DATA_RETURNED`: Not enough breaches data
      returned for correlation analysis
    * `NOT_ENOUGH_DATA_RETURNED`: Not enough data (breaches and normal
      rows) returned for correlation analysis
    * `NOT_ENOUGH_NORM_DATA_RETURNED`: Not enough normal data returned
      for correlation analysis
    * `NO_EXPLANATORY_FIELDS`: Unable to identify explanatory fields
    * `NO_HISTORY_ACCESS_METHOD_SELECTED`: No relevant history access
      method could be selected
    * `NO_TIME_FIELDS`: Unable to identify time fields
    * `PERMISSION_FAILURE`: Failure due to insufficient permissions
    * `QUERY_TIMEOUT`: RCA query timeout
    * `RCA_QUOTA_EXCEEDED`: RCA quota exceeded. Not running.
    * `RESOURCES_EXCEEDED`: Resources exceeded when running query.
    * `S3_OBJECT_WRITER_NOT_SUPPORTED`: S3 object writer not supported
    * `SQL_COMPILATION_ERROR`: Error in SQL RCA query.
    * `TABLE_TYPE_NOT_SUPPORTED`: Table type not supported
    * `UNKNOWN`: RCA failure needs further investigation to determine
      failure cause.
    * `WAREHOUSE_DISABLED`: Warehouse disabled for RCA
    * `WAREHOUSE_NOT_SUPPORTED`: RCA warehouse not supported
    """

    __schema__ = schema
    __choices__ = (
        "BAD_METRIC_EXPRESSION",
        "BAD_RULE_CONFIGURATION",
        "BASELINE_SAMPLE_INSUFFICIENT",
        "BREACHES_SAMPLE_INSUFFICIENT",
        "CONNECTION_NOT_SUPPORTED",
        "DATA_SAMPLING_DISABLED",
        "DOES_NOT_MEET_CRITERIA",
        "DUPLICATE_EVENT",
        "EVENT_MISSING_INCIDENT",
        "EVENT_MISSING_TABLE",
        "HIGH_BREACHING_MONITOR",
        "MISSING_EVENT_WAREHOUSE",
        "NOT_ENOUGH_BREACHES_DATA_RETURNED",
        "NOT_ENOUGH_DATA_RETURNED",
        "NOT_ENOUGH_NORM_DATA_RETURNED",
        "NO_EXPLANATORY_FIELDS",
        "NO_HISTORY_ACCESS_METHOD_SELECTED",
        "NO_TIME_FIELDS",
        "PERMISSION_FAILURE",
        "QUERY_TIMEOUT",
        "RCA_QUOTA_EXCEEDED",
        "RESOURCES_EXCEEDED",
        "S3_OBJECT_WRITER_NOT_SUPPORTED",
        "SQL_COMPILATION_ERROR",
        "TABLE_TYPE_NOT_SUPPORTED",
        "UNKNOWN",
        "WAREHOUSE_DISABLED",
        "WAREHOUSE_NOT_SUPPORTED",
    )


class ExecDashboardMetrics(sgqlc.types.Enum):
    """Available executive dashboard metrics.      For series, we
    use the plural. Ex: INCIDENTS_COUNTS, vs. singular for single. Ex:
    TABLES_COUNT

    Enumeration Choices:

    * `DAILY_MUTED_TABLES_COUNTS`None
    * `DAILY_NON_MUTED_TABLES_COUNTS`None
    * `DAILY_TABLES_COUNTS`None
    * `DECLARED_INCIDENTS_BY_SEVERITY_AND_TYPE_COUNTS`None
    * `DECLARED_INCIDENTS_BY_SEVERITY_COUNTS`None
    * `DECLARED_INCIDENTS_COUNTS`None
    * `DECLARED_INCIDENTS_TIME_TO_RESOLVED`None
    * `FIELD_MONITOR_UPTIME_PCT`None
    * `FRESHNESS_UPTIME_PCT`None
    * `INCIDENTS_COUNTS`None
    * `INCIDENTS_MEDIAN_TIME_TO_FIRST_RESPONSE`None
    * `INCIDENTS_MEDIAN_TIME_TO_RESOLUTION`None
    * `INCIDENTS_STATUS_UPDATE_RATE`None
    * `MONITORS_CREATED_COUNT`None
    * `MONITORS_INCIDENTS_COUNTS`None
    * `OOTB_FRESHNESS_UPTIME_PCT`None
    * `OOTB_VOLUME_UPTIME_PCT`None
    * `SQL_RULES_UPTIME_PCT`None
    * `STACK_SUMMARY`None
    * `USER_APP_VIEWS_COUNTS`None
    * `USER_PAGE_VIEWS_COUNTS`None
    * `USER_VISITS_COUNTS`None
    * `VOLUME_UPTIME_PCT`None
    """

    __schema__ = schema
    __choices__ = (
        "DAILY_MUTED_TABLES_COUNTS",
        "DAILY_NON_MUTED_TABLES_COUNTS",
        "DAILY_TABLES_COUNTS",
        "DECLARED_INCIDENTS_BY_SEVERITY_AND_TYPE_COUNTS",
        "DECLARED_INCIDENTS_BY_SEVERITY_COUNTS",
        "DECLARED_INCIDENTS_COUNTS",
        "DECLARED_INCIDENTS_TIME_TO_RESOLVED",
        "FIELD_MONITOR_UPTIME_PCT",
        "FRESHNESS_UPTIME_PCT",
        "INCIDENTS_COUNTS",
        "INCIDENTS_MEDIAN_TIME_TO_FIRST_RESPONSE",
        "INCIDENTS_MEDIAN_TIME_TO_RESOLUTION",
        "INCIDENTS_STATUS_UPDATE_RATE",
        "MONITORS_CREATED_COUNT",
        "MONITORS_INCIDENTS_COUNTS",
        "OOTB_FRESHNESS_UPTIME_PCT",
        "OOTB_VOLUME_UPTIME_PCT",
        "SQL_RULES_UPTIME_PCT",
        "STACK_SUMMARY",
        "USER_APP_VIEWS_COUNTS",
        "USER_PAGE_VIEWS_COUNTS",
        "USER_VISITS_COUNTS",
        "VOLUME_UPTIME_PCT",
    )


class ExecDashboardTables(sgqlc.types.Enum):
    """Available executive dashboard tables.

    Enumeration Choices:

    * `DOMAINS_TABLE`None
    * `MONITORS_TABLE`None
    * `USERS_TABLE`None
    """

    __schema__ = schema
    __choices__ = ("DOMAINS_TABLE", "MONITORS_TABLE", "USERS_TABLE")


class FacetType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BI_TYPES`None
    * `DATASETS`None
    * `DATA_PRODUCTS`None
    * `ETL_TYPES`None
    * `PROJECTS`None
    * `RESOURCE_TYPES`None
    * `TAGS`None
    * `TAG_NAMES`None
    * `TAG_VALUES`None
    * `WAREHOUSE_TYPES`None
    """

    __schema__ = schema
    __choices__ = (
        "BI_TYPES",
        "DATASETS",
        "DATA_PRODUCTS",
        "ETL_TYPES",
        "PROJECTS",
        "RESOURCE_TYPES",
        "TAGS",
        "TAG_NAMES",
        "TAG_VALUES",
        "WAREHOUSE_TYPES",
    )


class FeedbackReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DETECTOR_MARKED_AS_NORMAL`None
    * `USER_MARKED_AS_NORMAL`None
    * `USER_UNMARKED_AS_NORMAL`None
    """

    __schema__ = schema
    __choices__ = ("DETECTOR_MARKED_AS_NORMAL", "USER_MARKED_AS_NORMAL", "USER_UNMARKED_AS_NORMAL")


class FieldConfigType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `FIRST`None
    * `LAST`None
    """

    __schema__ = schema
    __choices__ = ("FIRST", "LAST")


class FieldHealthMetrics(sgqlc.types.Enum):
    """Field Health monitor opt-in metrics.

    Enumeration Choices:

    * `EMPTY_STRING_RATE`None
    * `FALSE_RATE`None
    * `FUTURE_TIMESTAMP_RATE`None
    * `NAN_RATE`None
    * `NEGATIVE_RATE`None
    * `NULL_RATE`None
    * `NUMERIC_MAX`None
    * `NUMERIC_MEAN`None
    * `NUMERIC_MEDIAN`None
    * `NUMERIC_MIN`None
    * `NUMERIC_QUANTILES`None
    * `NUMERIC_STDDEV`None
    * `PAST_TIMESTAMP_RATE`None
    * `PERCENTILE_20`None
    * `PERCENTILE_40`None
    * `PERCENTILE_60`None
    * `PERCENTILE_80`None
    * `TEXT_ALL_SPACE_RATE`None
    * `TEXT_EMAIL_ADDRESS_RATE`None
    * `TEXT_INT_RATE`None
    * `TEXT_MAX_LENGTH`None
    * `TEXT_MEAN_LENGTH`None
    * `TEXT_MIN_LENGTH`None
    * `TEXT_NULL_KEYWORD_RATE`None
    * `TEXT_NUMBER_RATE`None
    * `TEXT_SSN_RATE`None
    * `TEXT_STD_LENGTH`None
    * `TEXT_TIMESTAMP_RATE`None
    * `TEXT_US_PHONE_RATE`None
    * `TEXT_US_STATE_CODE_RATE`None
    * `TEXT_US_ZIP_CODE_RATE`None
    * `TEXT_UUID_RATE`None
    * `TRUE_RATE`None
    * `UNIQUE_RATE`None
    * `UNIX_ZERO_RATE`None
    * `ZERO_RATE`None
    """

    __schema__ = schema
    __choices__ = (
        "EMPTY_STRING_RATE",
        "FALSE_RATE",
        "FUTURE_TIMESTAMP_RATE",
        "NAN_RATE",
        "NEGATIVE_RATE",
        "NULL_RATE",
        "NUMERIC_MAX",
        "NUMERIC_MEAN",
        "NUMERIC_MEDIAN",
        "NUMERIC_MIN",
        "NUMERIC_QUANTILES",
        "NUMERIC_STDDEV",
        "PAST_TIMESTAMP_RATE",
        "PERCENTILE_20",
        "PERCENTILE_40",
        "PERCENTILE_60",
        "PERCENTILE_80",
        "TEXT_ALL_SPACE_RATE",
        "TEXT_EMAIL_ADDRESS_RATE",
        "TEXT_INT_RATE",
        "TEXT_MAX_LENGTH",
        "TEXT_MEAN_LENGTH",
        "TEXT_MIN_LENGTH",
        "TEXT_NULL_KEYWORD_RATE",
        "TEXT_NUMBER_RATE",
        "TEXT_SSN_RATE",
        "TEXT_STD_LENGTH",
        "TEXT_TIMESTAMP_RATE",
        "TEXT_US_PHONE_RATE",
        "TEXT_US_STATE_CODE_RATE",
        "TEXT_US_ZIP_CODE_RATE",
        "TEXT_UUID_RATE",
        "TRUE_RATE",
        "UNIQUE_RATE",
        "UNIX_ZERO_RATE",
        "ZERO_RATE",
    )


class FieldMetricCategory(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPLETENESS`None
    * `CUSTOM`None
    * `DISTRIBUTION`None
    * `PIPELINE`None
    * `UNIQUENESS`None
    * `VALIDITY`None
    """

    __schema__ = schema
    __choices__ = ("COMPLETENESS", "CUSTOM", "DISTRIBUTION", "PIPELINE", "UNIQUENESS", "VALIDITY")


class FieldMetricType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `APPROX_DISTINCTNESS`None
    * `APPROX_DISTINCT_COUNT`None
    * `APPROX_QUANTILES`None
    * `DUPLICATE_COUNT`None
    * `EMPTY_STRING_COUNT`None
    * `EMPTY_STRING_RATE`None
    * `FALSE_COUNT`None
    * `FALSE_RATE`None
    * `FUTURE_TIMESTAMP_COUNT`None
    * `FUTURE_TIMESTAMP_RATE`None
    * `MAX_LENGTH`None
    * `MEAN_LENGTH`None
    * `MIN_LENGTH`None
    * `NAN_COUNT`None
    * `NAN_RATE`None
    * `NEGATIVE_COUNT`None
    * `NEGATIVE_RATE`None
    * `NON_NULL_COUNT`None
    * `NULL_COUNT`None
    * `NULL_RATE`None
    * `NUMERIC_MAX`None
    * `NUMERIC_MEAN`None
    * `NUMERIC_MEDIAN`None
    * `NUMERIC_MIN`None
    * `NUMERIC_QUANTILES`None
    * `NUMERIC_STDDEV`None
    * `P20`None
    * `P40`None
    * `P60`None
    * `P80`None
    * `PAST_TIMESTAMP_COUNT`None
    * `PAST_TIMESTAMP_RATE`None
    * `PERCENTILE_20`None
    * `PERCENTILE_40`None
    * `PERCENTILE_60`None
    * `PERCENTILE_80`None
    * `PMAX`None
    * `PMIN`None
    * `RELATIVE_ROW_COUNT`None
    * `ROW_COUNT`None
    * `ROW_COUNT_CHANGE`None
    * `SUM`None
    * `TEXT_ALL_SPACES_COUNT`None
    * `TEXT_ALL_SPACES_RATE`None
    * `TEXT_ALL_SPACE_COUNT`None
    * `TEXT_ALL_SPACE_RATE`None
    * `TEXT_EMAIL_ADDRESS_RATE`None
    * `TEXT_INT_RATE`None
    * `TEXT_MAX_LENGTH`None
    * `TEXT_MEAN_LENGTH`None
    * `TEXT_MIN_LENGTH`None
    * `TEXT_NOT_EMAIL_ADDRESS_COUNT`None
    * `TEXT_NOT_INT_COUNT`None
    * `TEXT_NOT_NUMBER_COUNT`None
    * `TEXT_NOT_SSN_COUNT`None
    * `TEXT_NOT_TIMESTAMP_COUNT`None
    * `TEXT_NOT_US_PHONE_COUNT`None
    * `TEXT_NOT_US_STATE_CODE_COUNT`None
    * `TEXT_NOT_US_ZIP_CODE_COUNT`None
    * `TEXT_NOT_UUID_COUNT`None
    * `TEXT_NULL_KEYWORD_COUNT`None
    * `TEXT_NULL_KEYWORD_RATE`None
    * `TEXT_NUMBER_RATE`None
    * `TEXT_SSN_RATE`None
    * `TEXT_STD_LENGTH`None
    * `TEXT_TIMESTAMP_RATE`None
    * `TEXT_US_PHONE_RATE`None
    * `TEXT_US_STATE_CODE_RATE`None
    * `TEXT_US_ZIP_CODE_RATE`None
    * `TEXT_UUID_RATE`None
    * `TIME_SINCE_LAST_ROW_COUNT_CHANGE`None
    * `TRUE_COUNT`None
    * `TRUE_RATE`None
    * `UNIQUE_COUNT`None
    * `UNIQUE_RATE`None
    * `UNIX_ZERO_COUNT`None
    * `UNIX_ZERO_RATE`None
    * `ZERO_COUNT`None
    * `ZERO_RATE`None
    """

    __schema__ = schema
    __choices__ = (
        "APPROX_DISTINCTNESS",
        "APPROX_DISTINCT_COUNT",
        "APPROX_QUANTILES",
        "DUPLICATE_COUNT",
        "EMPTY_STRING_COUNT",
        "EMPTY_STRING_RATE",
        "FALSE_COUNT",
        "FALSE_RATE",
        "FUTURE_TIMESTAMP_COUNT",
        "FUTURE_TIMESTAMP_RATE",
        "MAX_LENGTH",
        "MEAN_LENGTH",
        "MIN_LENGTH",
        "NAN_COUNT",
        "NAN_RATE",
        "NEGATIVE_COUNT",
        "NEGATIVE_RATE",
        "NON_NULL_COUNT",
        "NULL_COUNT",
        "NULL_RATE",
        "NUMERIC_MAX",
        "NUMERIC_MEAN",
        "NUMERIC_MEDIAN",
        "NUMERIC_MIN",
        "NUMERIC_QUANTILES",
        "NUMERIC_STDDEV",
        "P20",
        "P40",
        "P60",
        "P80",
        "PAST_TIMESTAMP_COUNT",
        "PAST_TIMESTAMP_RATE",
        "PERCENTILE_20",
        "PERCENTILE_40",
        "PERCENTILE_60",
        "PERCENTILE_80",
        "PMAX",
        "PMIN",
        "RELATIVE_ROW_COUNT",
        "ROW_COUNT",
        "ROW_COUNT_CHANGE",
        "SUM",
        "TEXT_ALL_SPACES_COUNT",
        "TEXT_ALL_SPACES_RATE",
        "TEXT_ALL_SPACE_COUNT",
        "TEXT_ALL_SPACE_RATE",
        "TEXT_EMAIL_ADDRESS_RATE",
        "TEXT_INT_RATE",
        "TEXT_MAX_LENGTH",
        "TEXT_MEAN_LENGTH",
        "TEXT_MIN_LENGTH",
        "TEXT_NOT_EMAIL_ADDRESS_COUNT",
        "TEXT_NOT_INT_COUNT",
        "TEXT_NOT_NUMBER_COUNT",
        "TEXT_NOT_SSN_COUNT",
        "TEXT_NOT_TIMESTAMP_COUNT",
        "TEXT_NOT_US_PHONE_COUNT",
        "TEXT_NOT_US_STATE_CODE_COUNT",
        "TEXT_NOT_US_ZIP_CODE_COUNT",
        "TEXT_NOT_UUID_COUNT",
        "TEXT_NULL_KEYWORD_COUNT",
        "TEXT_NULL_KEYWORD_RATE",
        "TEXT_NUMBER_RATE",
        "TEXT_SSN_RATE",
        "TEXT_STD_LENGTH",
        "TEXT_TIMESTAMP_RATE",
        "TEXT_US_PHONE_RATE",
        "TEXT_US_STATE_CODE_RATE",
        "TEXT_US_ZIP_CODE_RATE",
        "TEXT_UUID_RATE",
        "TIME_SINCE_LAST_ROW_COUNT_CHANGE",
        "TRUE_COUNT",
        "TRUE_RATE",
        "UNIQUE_COUNT",
        "UNIQUE_RATE",
        "UNIX_ZERO_COUNT",
        "UNIX_ZERO_RATE",
        "ZERO_COUNT",
        "ZERO_RATE",
    )


class FieldMode(sgqlc.types.Enum):
    """Enumeration Choices:

    * `NULLABLE`None
    * `REPEATED`None
    * `REQUIRED`None
    """

    __schema__ = schema
    __choices__ = ("NULLABLE", "REPEATED", "REQUIRED")


class FieldQueryType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `APPROX_DISTINCTNESS`None
    * `APPROX_DISTINCT_COUNT`None
    * `APPROX_QUANTILES`None
    * `CUSTOM`None
    * `DUPLICATE_COUNT`None
    * `EMPTY_STRING_COUNT`None
    * `EMPTY_STRING_RATE`None
    * `FALSE_COUNT`None
    * `FALSE_RATE`None
    * `FUTURE_TIMESTAMP_COUNT`None
    * `FUTURE_TIMESTAMP_RATE`None
    * `MAX_LENGTH`None
    * `MEAN_LENGTH`None
    * `MIN_LENGTH`None
    * `NAN_COUNT`None
    * `NAN_RATE`None
    * `NEGATIVE_COUNT`None
    * `NEGATIVE_RATE`None
    * `NON_NULL_COUNT`None
    * `NULL_COUNT`None
    * `NULL_RATE`None
    * `NUMERIC_MAX`None
    * `NUMERIC_MEAN`None
    * `NUMERIC_MEDIAN`None
    * `NUMERIC_MIN`None
    * `NUMERIC_QUANTILES`None
    * `NUMERIC_STDDEV`None
    * `P20`None
    * `P40`None
    * `P60`None
    * `P80`None
    * `PAST_TIMESTAMP_COUNT`None
    * `PAST_TIMESTAMP_RATE`None
    * `PERCENTILE_20`None
    * `PERCENTILE_40`None
    * `PERCENTILE_60`None
    * `PERCENTILE_80`None
    * `PMAX`None
    * `PMIN`None
    * `RELATIVE_ROW_COUNT`None
    * `ROW_COUNT`None
    * `ROW_COUNT_CHANGE`None
    * `SUM`None
    * `TEXT_ALL_SPACES_COUNT`None
    * `TEXT_ALL_SPACES_RATE`None
    * `TEXT_ALL_SPACE_COUNT`None
    * `TEXT_ALL_SPACE_RATE`None
    * `TEXT_EMAIL_ADDRESS_RATE`None
    * `TEXT_INT_RATE`None
    * `TEXT_MAX_LENGTH`None
    * `TEXT_MEAN_LENGTH`None
    * `TEXT_MIN_LENGTH`None
    * `TEXT_NOT_EMAIL_ADDRESS_COUNT`None
    * `TEXT_NOT_INT_COUNT`None
    * `TEXT_NOT_NUMBER_COUNT`None
    * `TEXT_NOT_SSN_COUNT`None
    * `TEXT_NOT_TIMESTAMP_COUNT`None
    * `TEXT_NOT_US_PHONE_COUNT`None
    * `TEXT_NOT_US_STATE_CODE_COUNT`None
    * `TEXT_NOT_US_ZIP_CODE_COUNT`None
    * `TEXT_NOT_UUID_COUNT`None
    * `TEXT_NULL_KEYWORD_COUNT`None
    * `TEXT_NULL_KEYWORD_RATE`None
    * `TEXT_NUMBER_RATE`None
    * `TEXT_SSN_RATE`None
    * `TEXT_STD_LENGTH`None
    * `TEXT_TIMESTAMP_RATE`None
    * `TEXT_US_PHONE_RATE`None
    * `TEXT_US_STATE_CODE_RATE`None
    * `TEXT_US_ZIP_CODE_RATE`None
    * `TEXT_UUID_RATE`None
    * `TIME_SINCE_LAST_ROW_COUNT_CHANGE`None
    * `TRUE_COUNT`None
    * `TRUE_RATE`None
    * `UNIQUE_COUNT`None
    * `UNIQUE_RATE`None
    * `UNIX_ZERO_COUNT`None
    * `UNIX_ZERO_RATE`None
    * `ZERO_COUNT`None
    * `ZERO_RATE`None
    """

    __schema__ = schema
    __choices__ = (
        "APPROX_DISTINCTNESS",
        "APPROX_DISTINCT_COUNT",
        "APPROX_QUANTILES",
        "CUSTOM",
        "DUPLICATE_COUNT",
        "EMPTY_STRING_COUNT",
        "EMPTY_STRING_RATE",
        "FALSE_COUNT",
        "FALSE_RATE",
        "FUTURE_TIMESTAMP_COUNT",
        "FUTURE_TIMESTAMP_RATE",
        "MAX_LENGTH",
        "MEAN_LENGTH",
        "MIN_LENGTH",
        "NAN_COUNT",
        "NAN_RATE",
        "NEGATIVE_COUNT",
        "NEGATIVE_RATE",
        "NON_NULL_COUNT",
        "NULL_COUNT",
        "NULL_RATE",
        "NUMERIC_MAX",
        "NUMERIC_MEAN",
        "NUMERIC_MEDIAN",
        "NUMERIC_MIN",
        "NUMERIC_QUANTILES",
        "NUMERIC_STDDEV",
        "P20",
        "P40",
        "P60",
        "P80",
        "PAST_TIMESTAMP_COUNT",
        "PAST_TIMESTAMP_RATE",
        "PERCENTILE_20",
        "PERCENTILE_40",
        "PERCENTILE_60",
        "PERCENTILE_80",
        "PMAX",
        "PMIN",
        "RELATIVE_ROW_COUNT",
        "ROW_COUNT",
        "ROW_COUNT_CHANGE",
        "SUM",
        "TEXT_ALL_SPACES_COUNT",
        "TEXT_ALL_SPACES_RATE",
        "TEXT_ALL_SPACE_COUNT",
        "TEXT_ALL_SPACE_RATE",
        "TEXT_EMAIL_ADDRESS_RATE",
        "TEXT_INT_RATE",
        "TEXT_MAX_LENGTH",
        "TEXT_MEAN_LENGTH",
        "TEXT_MIN_LENGTH",
        "TEXT_NOT_EMAIL_ADDRESS_COUNT",
        "TEXT_NOT_INT_COUNT",
        "TEXT_NOT_NUMBER_COUNT",
        "TEXT_NOT_SSN_COUNT",
        "TEXT_NOT_TIMESTAMP_COUNT",
        "TEXT_NOT_US_PHONE_COUNT",
        "TEXT_NOT_US_STATE_CODE_COUNT",
        "TEXT_NOT_US_ZIP_CODE_COUNT",
        "TEXT_NOT_UUID_COUNT",
        "TEXT_NULL_KEYWORD_COUNT",
        "TEXT_NULL_KEYWORD_RATE",
        "TEXT_NUMBER_RATE",
        "TEXT_SSN_RATE",
        "TEXT_STD_LENGTH",
        "TEXT_TIMESTAMP_RATE",
        "TEXT_US_PHONE_RATE",
        "TEXT_US_STATE_CODE_RATE",
        "TEXT_US_ZIP_CODE_RATE",
        "TEXT_UUID_RATE",
        "TIME_SINCE_LAST_ROW_COUNT_CHANGE",
        "TRUE_COUNT",
        "TRUE_RATE",
        "UNIQUE_COUNT",
        "UNIQUE_RATE",
        "UNIX_ZERO_COUNT",
        "UNIX_ZERO_RATE",
        "ZERO_COUNT",
        "ZERO_RATE",
    )


class FieldType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BOOLEAN`None
    * `DATE`None
    * `NUMERIC`None
    * `TEXT`None
    * `TIME`None
    * `TIME_OF_DAY`None
    * `UNKNOWN`None
    """

    __schema__ = schema
    __choices__ = ("BOOLEAN", "DATE", "NUMERIC", "TEXT", "TIME", "TIME_OF_DAY", "UNKNOWN")


class FieldValueFilterOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXCLUDE`None
    * `INCLUDE`None
    """

    __schema__ = schema
    __choices__ = ("EXCLUDE", "INCLUDE")


class FilterType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BINARY`None
    * `GROUP`None
    * `SQL`None
    * `UNARY`None
    """

    __schema__ = schema
    __choices__ = ("BINARY", "GROUP", "SQL", "UNARY")


class FilterValueType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `FIELD`None
    * `LITERAL`None
    * `SQL`None
    """

    __schema__ = schema
    __choices__ = ("FIELD", "LITERAL", "SQL")


class FivetranConnectorSetupStates(sgqlc.types.Enum):
    """Defines the current setup state of a Fivetran Connector

    Enumeration Choices:

    * `BROKEN`None
    * `CONNECTED`None
    * `INCOMPLETE`None
    """

    __schema__ = schema
    __choices__ = ("BROKEN", "CONNECTED", "INCOMPLETE")


class FivetranConnectorStatuses(sgqlc.types.Enum):
    """Defines the user facing statues of Fivetran connectors.
    See: https://fivetran.com/docs/getting-started/fivetran-
    dashboard/connectors#connectorstatus

    Enumeration Choices:

    * `Active`None
    * `Broken`None
    * `Delayed`None
    * `Incomplete`None
    * `Paused`None
    """

    __schema__ = schema
    __choices__ = ("Active", "Broken", "Delayed", "Incomplete", "Paused")


class FivetranConnectorSyncStates(sgqlc.types.Enum):
    """Defines the current sync state of a Fivetran Connector

    Enumeration Choices:

    * `PAUSED`None
    * `RESCHEDULED`None
    * `SCHEDULED`None
    * `SYNCING`None
    """

    __schema__ = schema
    __choices__ = ("PAUSED", "RESCHEDULED", "SCHEDULED", "SYNCING")


class FivetranConnectorUpdateStates(sgqlc.types.Enum):
    """Defines the current data update state of a Fivetran connector

    Enumeration Choices:

    * `DELAYED`None
    * `ON_SCHEDULE`None
    """

    __schema__ = schema
    __choices__ = ("DELAYED", "ON_SCHEDULE")


Float = sgqlc.types.Float


class GenericScalar(sgqlc.types.Scalar):
    """The `GenericScalar` scalar type represents a generic GraphQL
    scalar value that could be: String, Boolean, Int, Float, List or
    Object.
    """

    __schema__ = schema


ID = sgqlc.types.ID


class IdempotentStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPLETED`None
    * `ERROR`None
    * `IN_PROGRESS`None
    """

    __schema__ = schema
    __choices__ = ("COMPLETED", "ERROR", "IN_PROGRESS")


class ImportanceScoreOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EQ`None
    * `GT`None
    * `GTE`None
    * `LT`None
    * `LTE`None
    * `RANGE`None
    """

    __schema__ = schema
    __choices__ = ("EQ", "GT", "GTE", "LT", "LTE", "RANGE")


class IncidentCategory(sgqlc.types.Enum):
    """Categories to classify incidents

    Enumeration Choices:

    * `dbt_errors`None
    * `dimension`None
    * `field_health`None
    * `field_quality_rule`None
    * `freshness`None
    * `schema`None
    * `sql_rule`None
    * `validation`None
    * `volume`None
    """

    __schema__ = schema
    __choices__ = (
        "dbt_errors",
        "dimension",
        "field_health",
        "field_quality_rule",
        "freshness",
        "schema",
        "sql_rule",
        "validation",
        "volume",
    )


class IncidentFeedback(sgqlc.types.Enum):
    """Enumeration Choices:

    * `expected`None
    * `false_positive`None
    * `fixed`None
    * `investigating`None
    * `no_action_needed`None
    * `no_status`None
    * `work_in_progress`None
    """

    __schema__ = schema
    __choices__ = (
        "expected",
        "false_positive",
        "fixed",
        "investigating",
        "no_action_needed",
        "no_status",
        "work_in_progress",
    )


class IncidentGroupBy(sgqlc.types.Enum):
    """Enumeration Choices:

    * `STATUS`None
    * `TYPE`None
    """

    __schema__ = schema
    __choices__ = ("STATUS", "TYPE")


class IncidentModelFeedback(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ANOMALY_NORMALIZED`: Anomaly normalized
    * `EXPECTED`: Expected
    * `FALSE_POSITIVE`: False positive
    * `FIXED`: Fixed
    * `HELPFUL`: Helpful
    * `INVESTIGATING`: Acknowledged
    * `NOT_HELPFUL`: Not helpful
    * `NO_ACTION_NEEDED`: No action needed
    * `WORK_IN_PROGRESS`: Work in progress
    """

    __schema__ = schema
    __choices__ = (
        "ANOMALY_NORMALIZED",
        "EXPECTED",
        "FALSE_POSITIVE",
        "FIXED",
        "HELPFUL",
        "INVESTIGATING",
        "NOT_HELPFUL",
        "NO_ACTION_NEEDED",
        "WORK_IN_PROGRESS",
    )


class IncidentModelIncidentType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT_ANOMALIES`: Agent anomalies
    * `ANOMALIES`: Anomalies
    * `CUSTOM_RULE_ANOMALIES`: Custom rule anomalies
    * `DBT_ERRORS`: dbt errors
    * `DELETED_TABLES`: Deleted tables
    * `ETL_ERRORS`: ETL errors
    * `JSON_SCHEMA_CHANGES`: JSON schema changes
    * `MERGED`: Merged alerts
    * `METRIC_ANOMALIES`: Metric anomalies
    * `METRIC_COMPARISON_ANOMALIES`: Metric Comparison Anomalies
    * `PERFORMANCE_ANOMALIES`: Performance anomalies
    * `PSEUDO_INTEGRATION_TEST`: Pseudo anomalies
    * `RULE_RUN_EXECUTION_ERROR`: Rule run failure
    * `SCHEMA_CHANGES`: Schema changes
    """

    __schema__ = schema
    __choices__ = (
        "AGENT_ANOMALIES",
        "ANOMALIES",
        "CUSTOM_RULE_ANOMALIES",
        "DBT_ERRORS",
        "DELETED_TABLES",
        "ETL_ERRORS",
        "JSON_SCHEMA_CHANGES",
        "MERGED",
        "METRIC_ANOMALIES",
        "METRIC_COMPARISON_ANOMALIES",
        "PERFORMANCE_ANOMALIES",
        "PSEUDO_INTEGRATION_TEST",
        "RULE_RUN_EXECUTION_ERROR",
        "SCHEMA_CHANGES",
    )


class IncidentModelPriority(sgqlc.types.Enum):
    """Enumeration Choices:

    * `P1`: P1
    * `P2`: P2
    * `P3`: P3
    * `P4`: P4
    * `P5`: P5
    """

    __schema__ = schema
    __choices__ = ("P1", "P2", "P3", "P4", "P5")


class IncidentSubType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `abnormal_size_change`None
    * `adf_job_failure`None
    * `agent_anomaly`None
    * `airflow_dag_failure`None
    * `comparison_rule_breach`None
    * `data_added`None
    * `data_removed`None
    * `databricks_job_failure`None
    * `dbt_model_error`None
    * `dbt_seed_error`None
    * `dbt_snapshot_error`None
    * `dbt_test_failure`None
    * `dbt_test_warning`None
    * `dimension_anomaly`None
    * `field_metrics_anomaly`None
    * `field_quality_rule_breach`None
    * `fields_added`None
    * `fields_changed`None
    * `fields_removed`None
    * `freshness_anomaly`None
    * `freshness_sli_rule_breach`None
    * `json_fields_added`None
    * `json_fields_removed`None
    * `json_schema_rule_breach`None
    * `metric_comparison_anomaly`None
    * `performance_anomaly`None
    * `sql_rule_breach`None
    * `unchanged_size`None
    * `validation_breach`None
    * `volume_anomaly`None
    * `volume_sli_rule_breach`None
    """

    __schema__ = schema
    __choices__ = (
        "abnormal_size_change",
        "adf_job_failure",
        "agent_anomaly",
        "airflow_dag_failure",
        "comparison_rule_breach",
        "data_added",
        "data_removed",
        "databricks_job_failure",
        "dbt_model_error",
        "dbt_seed_error",
        "dbt_snapshot_error",
        "dbt_test_failure",
        "dbt_test_warning",
        "dimension_anomaly",
        "field_metrics_anomaly",
        "field_quality_rule_breach",
        "fields_added",
        "fields_changed",
        "fields_removed",
        "freshness_anomaly",
        "freshness_sli_rule_breach",
        "json_fields_added",
        "json_fields_removed",
        "json_schema_rule_breach",
        "metric_comparison_anomaly",
        "performance_anomaly",
        "sql_rule_breach",
        "unchanged_size",
        "validation_breach",
        "volume_anomaly",
        "volume_sli_rule_breach",
    )


class IncidentsFilterFields(sgqlc.types.Enum):
    """Enumeration Choices:

    * `audience`None
    * `contains_key_asset`None
    * `dataset`None
    * `domain`None
    * `incident_type`None
    * `include_normalized`None
    * `jira`None
    * `opsgenie`None
    * `owner`None
    * `priority`None
    * `project`None
    * `servicenow`None
    * `severity`None
    * `status`None
    * `table`None
    * `tag`None
    """

    __schema__ = schema
    __choices__ = (
        "audience",
        "contains_key_asset",
        "dataset",
        "domain",
        "incident_type",
        "include_normalized",
        "jira",
        "opsgenie",
        "owner",
        "priority",
        "project",
        "servicenow",
        "severity",
        "status",
        "table",
        "tag",
    )


class InformaticaActivityType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `TASK`None
    * `TASK_FLOW`None
    * `UNKNOWN`None
    """

    __schema__ = schema
    __choices__ = ("TASK", "TASK_FLOW", "UNKNOWN")


Int = sgqlc.types.Int


class IntegrationKeyScope(sgqlc.types.Enum):
    """Enumeration Choices:

    * `Agent`None
    * `AirflowCallbacks`None
    * `AzureDevopsWebhook`None
    * `CircuitBreaker`None
    * `DatabricksWebhook`None
    * `DbtCloudWebhook`None
    * `MCP`None
    * `S3PresignedUrl`None
    * `SCIM_v2`None
    * `Spark`None
    """

    __schema__ = schema
    __choices__ = (
        "Agent",
        "AirflowCallbacks",
        "AzureDevopsWebhook",
        "CircuitBreaker",
        "DatabricksWebhook",
        "DbtCloudWebhook",
        "MCP",
        "S3PresignedUrl",
        "SCIM_v2",
        "Spark",
    )


class InternalJobType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT_REACHABILITY`None
    * `AGENT_SPANS`None
    * `DIRECT_LINEAGE`None
    * `ETL`None
    * `JSON_SCHEMA`None
    * `METADATA`None
    * `QUERY_LOGS`None
    * `QUERY_LOGS_BOOTSTRAP`None
    * `REPORTS`None
    * `S3_METADATA_EVENTS`None
    * `S3_QL_EVENTS`None
    * `SLO`None
    * `SQL_QUERY`None
    * `STREAM_METADATA`None
    * `TABLEAU_GQL`None
    """

    __schema__ = schema
    __choices__ = (
        "AGENT_REACHABILITY",
        "AGENT_SPANS",
        "DIRECT_LINEAGE",
        "ETL",
        "JSON_SCHEMA",
        "METADATA",
        "QUERY_LOGS",
        "QUERY_LOGS_BOOTSTRAP",
        "REPORTS",
        "S3_METADATA_EVENTS",
        "S3_QL_EVENTS",
        "SLO",
        "SQL_QUERY",
        "STREAM_METADATA",
        "TABLEAU_GQL",
    )


class InvitationType(sgqlc.types.Enum):
    """Used to select the template to use for new user invites.

    Enumeration Choices:

    * `Observability`None
    """

    __schema__ = schema
    __choices__ = ("Observability",)


class IsNotMonitoredReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACCOUNT_NOT_BASED_ON_MONITORING`None
    * `INGESTION_EXCLUSION_RULE_OTHER`None
    * `MONITORING_EXCLUSION_RULE_OTHER`None
    * `MONITORING_INCLUSION_MISSING_OTHER`None
    * `NON_MONITORABLE_BI`None
    * `NOT_FOUND_IN_METADATA_COLLECTION_OTHER`None
    * `NOT_MONITORABLE_OTHER`None
    * `NO_REASON_FOUND`None
    """

    __schema__ = schema
    __choices__ = (
        "ACCOUNT_NOT_BASED_ON_MONITORING",
        "INGESTION_EXCLUSION_RULE_OTHER",
        "MONITORING_EXCLUSION_RULE_OTHER",
        "MONITORING_INCLUSION_MISSING_OTHER",
        "NON_MONITORABLE_BI",
        "NOT_FOUND_IN_METADATA_COLLECTION_OTHER",
        "NOT_MONITORABLE_OTHER",
        "NO_REASON_FOUND",
    )


class JSONString(sgqlc.types.Scalar):
    """Allows use of a JSON String for input / output from the GraphQL
    schema.  Use of this type is *not recommended* as you lose the
    benefits of having a defined, static schema (one of the key
    benefits of GraphQL).
    """

    __schema__ = schema


class JobExecutionStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CANCELLED`None
    * `EVALUATING`None
    * `FAILED`None
    * `IN_PROGRESS`None
    * `SUCCESS`None
    * `TIMEOUT`None
    """

    __schema__ = schema
    __choices__ = ("CANCELLED", "EVALUATING", "FAILED", "IN_PROGRESS", "SUCCESS", "TIMEOUT")


class JobPerformanceFacet(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DBT_PROJECT`None
    * `DOMAIN`None
    * `ETL_CONTAINER`None
    * `JOB_NAME`None
    * `JOB_TYPE`None
    * `LAST_RUN_STATUS`None
    * `TAGS`None
    """

    __schema__ = schema
    __choices__ = (
        "DBT_PROJECT",
        "DOMAIN",
        "ETL_CONTAINER",
        "JOB_NAME",
        "JOB_TYPE",
        "LAST_RUN_STATUS",
        "TAGS",
    )


class JobsPerformanceSummarySort(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AVG_RUN_DURATION`None
    * `DISPLAY_NAME`None
    * `FAILURE_RATE`None
    * `INTEGRATION_TYPE`None
    * `LAST_RUN_END_TIME`None
    * `LAST_RUN_START_TIME`None
    * `LAST_RUN_STATUS`None
    * `LAST_RUN_UUID`None
    * `MCON`None
    * `RUN_COUNT`None
    * `RUN_DURATION_TREND_7D`None
    """

    __schema__ = schema
    __choices__ = (
        "AVG_RUN_DURATION",
        "DISPLAY_NAME",
        "FAILURE_RATE",
        "INTEGRATION_TYPE",
        "LAST_RUN_END_TIME",
        "LAST_RUN_START_TIME",
        "LAST_RUN_STATUS",
        "LAST_RUN_UUID",
        "MCON",
        "RUN_COUNT",
        "RUN_DURATION_TREND_7D",
    )


class LineageFilterName(sgqlc.types.Enum):
    """Enumeration Choices:

    * `OBJECT_TYPE`None
    """

    __schema__ = schema
    __choices__ = ("OBJECT_TYPE",)


class LineageFilterOperator(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXCLUDE`None
    * `INCLUDE`None
    """

    __schema__ = schema
    __choices__ = ("EXCLUDE", "INCLUDE")


class LineageGraphTraversalDirection(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BOTH`None
    * `DOWNSTREAM`None
    * `UPSTREAM`None
    """

    __schema__ = schema
    __choices__ = ("BOTH", "DOWNSTREAM", "UPSTREAM")


class LineageNodeJobDirectionType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `dest`None
    * `source`None
    """

    __schema__ = schema
    __choices__ = ("dest", "source")


class LineageNodeJobType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AIRFLOW`None
    * `AZURE_DATA_FACTORY`None
    * `CONFLUENT_KAFKA_CONNECT`None
    * `DATABRICKS`None
    * `DBT_CLOUD`None
    * `DBT_CORE`None
    * `FIVETRAN`None
    * `INFORMATICA`None
    * `MSK_KAFKA_CONNECT`None
    * `SELF_HOSTED_KAFKA_CONNECT`None
    * `UNKNOWN`None
    """

    __schema__ = schema
    __choices__ = (
        "AIRFLOW",
        "AZURE_DATA_FACTORY",
        "CONFLUENT_KAFKA_CONNECT",
        "DATABRICKS",
        "DBT_CLOUD",
        "DBT_CORE",
        "FIVETRAN",
        "INFORMATICA",
        "MSK_KAFKA_CONNECT",
        "SELF_HOSTED_KAFKA_CONNECT",
        "UNKNOWN",
    )


class LogsIntegrationType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DEFAULT`None
    """

    __schema__ = schema
    __choices__ = ("DEFAULT",)


class LookbackRange(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ONE_DAY`None
    * `ONE_HOUR`None
    * `SEVEN_DAY`None
    * `TWELVE_HOUR`None
    """

    __schema__ = schema
    __choices__ = ("ONE_DAY", "ONE_HOUR", "SEVEN_DAY", "TWELVE_HOUR")


class MetricDataType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `NUMERIC`None
    * `PERCENTAGE`None
    * `STRING`None
    """

    __schema__ = schema
    __choices__ = ("NUMERIC", "PERCENTAGE", "STRING")


class MetricMonitorSelectExpressionModelDataType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BOOLEAN`: BOOLEAN
    * `DATETIME`: DATETIME
    * `NUMERIC`: NUMERIC
    * `STRING`: STRING
    """

    __schema__ = schema
    __choices__ = ("BOOLEAN", "DATETIME", "NUMERIC", "STRING")


class MetricMonitoringBootstrapState(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPLETED`None
    * `FAILED`None
    * `LOADING_HISTORY`None
    * `PAUSED`None
    * `PENDING`None
    * `SKIPPED_HISTORY`None
    * `TIMEOUT`None
    * `WAITING`None
    """

    __schema__ = schema
    __choices__ = (
        "COMPLETED",
        "FAILED",
        "LOADING_HISTORY",
        "PAUSED",
        "PENDING",
        "SKIPPED_HISTORY",
        "TIMEOUT",
        "WAITING",
    )


class MetricMonitoringModelPriority(sgqlc.types.Enum):
    """Enumeration Choices:

    * `P1`: P1
    * `P2`: P2
    * `P3`: P3
    * `P4`: P4
    * `P5`: P5
    """

    __schema__ = schema
    __choices__ = ("P1", "P2", "P3", "P4", "P5")


class MetricMonitoringModelType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT`: Agent
    * `CATEGORIES`: Dimension
    * `HOURLY_STATS`: Statistical metrics over an hour interval
    * `JSON_SCHEMA`: JSON schema
    * `METRIC_COMPARISON`: Comparison
    * `STATS`: Metric
    """

    __schema__ = schema
    __choices__ = (
        "AGENT",
        "CATEGORIES",
        "HOURLY_STATS",
        "JSON_SCHEMA",
        "METRIC_COMPARISON",
        "STATS",
    )


class ModelExecutionTypes(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DBT`None
    """

    __schema__ = schema
    __choices__ = ("DBT",)


class MonitorAggTimeInterval(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DAY`None
    * `HOUR`None
    * `MONTH`None
    * `WEEK`None
    """

    __schema__ = schema
    __choices__ = ("DAY", "HOUR", "MONTH", "WEEK")


class MonitorBreachType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BREACHED`None
    * `NOT_BREACHED`None
    """

    __schema__ = schema
    __choices__ = ("BREACHED", "NOT_BREACHED")


class MonitorConfigurationStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ERROR`None
    * `INCOMPLETE`None
    * `NOT_RUN`None
    * `NO_TIME_AXIS`None
    * `NO_TIME_AXIS_BIG_TABLE`None
    * `SUCCESS`None
    """

    __schema__ = schema
    __choices__ = (
        "ERROR",
        "INCOMPLETE",
        "NOT_RUN",
        "NO_TIME_AXIS",
        "NO_TIME_AXIS_BIG_TABLE",
        "SUCCESS",
    )


class MonitorConfigurationStatusType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `MISCONFIGURED`None
    * `NO_STATUS`None
    * `SUCCESS`None
    """

    __schema__ = schema
    __choices__ = ("MISCONFIGURED", "NO_STATUS", "SUCCESS")


class MonitorLabelsMatchType(sgqlc.types.Enum):
    """Used to select the logical operator for matching labels

    Enumeration Choices:

    * `AND`None
    * `OR`None
    """

    __schema__ = schema
    __choices__ = ("AND", "OR")


class MonitorRecommendationModel(sgqlc.types.Enum):
    """Enumeration Choices:

    * `METRIC`None
    * `REGEX`None
    * `SEGMENTATION`None
    * `VALIDATION`None
    """

    __schema__ = schema
    __choices__ = ("METRIC", "REGEX", "SEGMENTATION", "VALIDATION")


class MonitorRecommendationType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AI_VALIDATION`None
    * `HEURISTIC`None
    """

    __schema__ = schema
    __choices__ = ("AI_VALIDATION", "HEURISTIC")


class MonitorRunStatusType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DRAFT`None
    * `ERROR`None
    * `IN_PROGRESS`None
    * `NO_STATUS`None
    * `PAUSED`None
    * `SNOOZED`None
    * `SUCCESS`None
    """

    __schema__ = schema
    __choices__ = ("DRAFT", "ERROR", "IN_PROGRESS", "NO_STATUS", "PAUSED", "SNOOZED", "SUCCESS")


class MonitorStatusType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DRAFT`None
    * `ERROR`None
    * `INSUFFICIENT_DATA`None
    * `IN_PROGRESS`None
    * `IN_TRAINING`None
    * `MISCONFIGURED`None
    * `NO_STATUS`None
    * `PAUSED`None
    * `SNOOZED`None
    * `SUCCESS`None
    """

    __schema__ = schema
    __choices__ = (
        "DRAFT",
        "ERROR",
        "INSUFFICIENT_DATA",
        "IN_PROGRESS",
        "IN_TRAINING",
        "MISCONFIGURED",
        "NO_STATUS",
        "PAUSED",
        "SNOOZED",
        "SUCCESS",
    )


class MonitorTrainingStatusType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `INSUFFICIENT_DATA`None
    * `IN_TRAINING`None
    * `NO_STATUS`None
    * `SUCCESS`None
    """

    __schema__ = schema
    __choices__ = ("INSUFFICIENT_DATA", "IN_TRAINING", "NO_STATUS", "SUCCESS")


class MonitoredRuleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AllTablesMonitoringRule`None
    * `DomainMonitoringRule`None
    * `LastActivityMonitoringRule`None
    * `TableNameMonitoringRule`None
    * `TableTagMonitoringRule`None
    * `TableTypeMonitoringRule`None
    """

    __schema__ = schema
    __choices__ = (
        "AllTablesMonitoringRule",
        "DomainMonitoringRule",
        "LastActivityMonitoringRule",
        "TableNameMonitoringRule",
        "TableTagMonitoringRule",
        "TableTypeMonitoringRule",
    )


class MonitoredTableRuleJobStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPLETED`None
    * `FAILED`None
    * `IN_PROGRESS`None
    * `QUEUED`None
    """

    __schema__ = schema
    __choices__ = ("COMPLETED", "FAILED", "IN_PROGRESS", "QUEUED")


class MonitoredTableRuleTableAttribute(sgqlc.types.Enum):
    """Enumeration Choices:

    * `last_activity`None
    * `read_activity`None
    * `table_id`None
    * `table_tag`None
    * `table_type`None
    * `write_activity`None
    """

    __schema__ = schema
    __choices__ = (
        "last_activity",
        "read_activity",
        "table_id",
        "table_tag",
        "table_type",
        "write_activity",
    )


class MonitoredTableRuleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `all`None
    * `exact_match`None
    * `gt`None
    * `in`None
    * `is_null`None
    * `lte`None
    * `prefix`None
    * `substring`None
    * `suffix`None
    * `wildcard_pattern`None
    """

    __schema__ = schema
    __choices__ = (
        "all",
        "exact_match",
        "gt",
        "in",
        "is_null",
        "lte",
        "prefix",
        "substring",
        "suffix",
        "wildcard_pattern",
    )


class MutedEventType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CUSTOM_RULE_ANOM`None
    * `DELETE_TABLE`None
    * `DIST_ANOM`None
    * `FRESH_ANOM`None
    * `JSON_SCHEMA_CHANGE`None
    * `METRIC_ANOM`None
    * `QUERY_RUNTIME_ANOM`None
    * `SCHEMA_CHANGE`None
    * `SIZE_ANOM`None
    * `SIZE_DIFF`None
    * `UNCHANGED_SIZE_ANOM`None
    * `VALIDATION_ANOM`None
    """

    __schema__ = schema
    __choices__ = (
        "CUSTOM_RULE_ANOM",
        "DELETE_TABLE",
        "DIST_ANOM",
        "FRESH_ANOM",
        "JSON_SCHEMA_CHANGE",
        "METRIC_ANOM",
        "QUERY_RUNTIME_ANOM",
        "SCHEMA_CHANGE",
        "SIZE_ANOM",
        "SIZE_DIFF",
        "UNCHANGED_SIZE_ANOM",
        "VALIDATION_ANOM",
    )


class NodeType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `MODEL`None
    * `SEED`None
    * `SNAPSHOT`None
    * `SOURCE`None
    * `TEST`None
    """

    __schema__ = schema
    __choices__ = ("MODEL", "SEED", "SNAPSHOT", "SOURCE", "TEST")


class OAuthGrantTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `client_credentials`None
    * `password`None
    """

    __schema__ = schema
    __choices__ = ("client_credentials", "password")


class ObjectPropertyModelPropertySourceType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COLLECTION`: Collection
    * `DASHBOARD`: Dashboard
    * `DATA_PRODUCT`: Data Product
    * `DBT`: DBT
    * `DOMAIN`: Domain
    * `LINEAGE_API`: Lineage API
    * `TAGS_COLLECTION`: Tags Collection
    """

    __schema__ = schema
    __choices__ = (
        "COLLECTION",
        "DASHBOARD",
        "DATA_PRODUCT",
        "DBT",
        "DOMAIN",
        "LINEAGE_API",
        "TAGS_COLLECTION",
    )


class OotbTableMonitorTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `FRESHNESS`None
    * `SCHEMA`None
    * `VOLUME_SIZE_DIFF`None
    * `VOLUME_UNCHANGED_SIZE`None
    """

    __schema__ = schema
    __choices__ = ("FRESHNESS", "SCHEMA", "VOLUME_SIZE_DIFF", "VOLUME_UNCHANGED_SIZE")


class PerformanceDashboardAccessValidationCode(sgqlc.types.Enum):
    """Performance dashboard access validation codes.

    Enumeration Choices:

    * `Admin_Disabled`None
    * `Ok`None
    * `Unauthorized`None
    * `Unsupported_Warehouse`None
    """

    __schema__ = schema
    __choices__ = ("Admin_Disabled", "Ok", "Unauthorized", "Unsupported_Warehouse")


class PeriodGrouping(sgqlc.types.Enum):
    """Time size of the periods.

    Enumeration Choices:

    * `DAY`None
    * `MONTH`None
    * `WEEK`None
    """

    __schema__ = schema
    __choices__ = ("DAY", "MONTH", "WEEK")


class Permission(sgqlc.types.Enum):
    """Currently-defined permissions.

    Enumeration Choices:

    * `CatalogAccess`None
    * `CatalogEdit`None
    * `DashboardAccess`None
    * `DashboardEdit`None
    * `DashboardEditTheirOwn`None
    * `DataExportsAccess`None
    * `DataproductsAccess`None
    * `DataproductsEdit`None
    * `DataproductsEditAll`None
    * `DataproductsEditTheirOwn`None
    * `GraphqlMutate`None
    * `GraphqlQuery`None
    * `IncidentsAccess`None
    * `IncidentsEdit`None
    * `IncidentsUpdateStatus`None
    * `MonitorsAccess`None
    * `MonitorsAggregates`None
    * `MonitorsDraft`None
    * `MonitorsEdit`None
    * `PerformanceAccess`None
    * `PipelinesAccess`None
    * `PipelinesEdit`None
    * `ProductsAccess`None
    * `ProductsDiscoveryAccess`None
    * `ProductsObservabilityAccess`None
    * `ProductsSamplingAccess`None
    * `SettingsAccess`None
    * `SettingsApiAccess`None
    * `SettingsApiEdit`None
    * `SettingsApiTokensManage`None
    * `SettingsBillingAccess`None
    * `SettingsCollectionPreferencesEdit`None
    * `SettingsCollectionPreferencesList`None
    * `SettingsCollectionPreferencesUpgrade`None
    * `SettingsDomainsAccess`None
    * `SettingsDomainsEdit`None
    * `SettingsDomainsList`None
    * `SettingsDomainsViewDetail`None
    * `SettingsEdit`None
    * `SettingsIntegrationsAccess`None
    * `SettingsIntegrationsEdit`None
    * `SettingsMutedDataAccess`None
    * `SettingsMutedDataEdit`None
    * `SettingsNotificationsAccess`None
    * `SettingsNotificationsEdit`None
    * `SettingsPiiFiltersEdit`None
    * `SettingsPiiFiltersList`None
    * `SettingsPiiFiltersViewMetrics`None
    * `SettingsSecretsAccess`None
    * `SettingsSecretsEdit`None
    * `SettingsSecretsValuesAccess`None
    * `SettingsUsageAccess`None
    * `SettingsUsageEdit`None
    * `SettingsUserSubscribeWeeklyDigest`None
    * `SettingsUsersAccess`None
    * `SettingsUsersEdit`None
    * `SettingsUsersEditAuthProvisioning`None
    * `SettingsUsersEditSso`None
    * `SettingsUsersManageDomainsManagers`None
    * `SettingsUsersManageOwners`None
    * `UsersList`None
    """

    __schema__ = schema
    __choices__ = (
        "CatalogAccess",
        "CatalogEdit",
        "DashboardAccess",
        "DashboardEdit",
        "DashboardEditTheirOwn",
        "DataExportsAccess",
        "DataproductsAccess",
        "DataproductsEdit",
        "DataproductsEditAll",
        "DataproductsEditTheirOwn",
        "GraphqlMutate",
        "GraphqlQuery",
        "IncidentsAccess",
        "IncidentsEdit",
        "IncidentsUpdateStatus",
        "MonitorsAccess",
        "MonitorsAggregates",
        "MonitorsDraft",
        "MonitorsEdit",
        "PerformanceAccess",
        "PipelinesAccess",
        "PipelinesEdit",
        "ProductsAccess",
        "ProductsDiscoveryAccess",
        "ProductsObservabilityAccess",
        "ProductsSamplingAccess",
        "SettingsAccess",
        "SettingsApiAccess",
        "SettingsApiEdit",
        "SettingsApiTokensManage",
        "SettingsBillingAccess",
        "SettingsCollectionPreferencesEdit",
        "SettingsCollectionPreferencesList",
        "SettingsCollectionPreferencesUpgrade",
        "SettingsDomainsAccess",
        "SettingsDomainsEdit",
        "SettingsDomainsList",
        "SettingsDomainsViewDetail",
        "SettingsEdit",
        "SettingsIntegrationsAccess",
        "SettingsIntegrationsEdit",
        "SettingsMutedDataAccess",
        "SettingsMutedDataEdit",
        "SettingsNotificationsAccess",
        "SettingsNotificationsEdit",
        "SettingsPiiFiltersEdit",
        "SettingsPiiFiltersList",
        "SettingsPiiFiltersViewMetrics",
        "SettingsSecretsAccess",
        "SettingsSecretsEdit",
        "SettingsSecretsValuesAccess",
        "SettingsUsageAccess",
        "SettingsUsageEdit",
        "SettingsUserSubscribeWeeklyDigest",
        "SettingsUsersAccess",
        "SettingsUsersEdit",
        "SettingsUsersEditAuthProvisioning",
        "SettingsUsersEditSso",
        "SettingsUsersManageDomainsManagers",
        "SettingsUsersManageOwners",
        "UsersList",
    )


class PermissionEffect(sgqlc.types.Enum):
    """Possible effects of a policy.

    Enumeration Choices:

    * `Allow`None
    * `Deny`None
    """

    __schema__ = schema
    __choices__ = ("Allow", "Deny")


class PiiFilteringFailModeType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CLOSE`None
    * `OPEN`None
    """

    __schema__ = schema
    __choices__ = ("CLOSE", "OPEN")


class PlatformServiceSupportCode(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DATA_STORE_NOT_SUPPORTED`: Data stores not supported by the
      service
    * `NEW_CONNECTIONS_NOT_SUPPORTED`: New connections not supported
      by the service
    * `REMOTE_AGENT_NOT_SUPPORTED`: Remote agents not supported by the
      service
    * `SUPPORTED`: The service supports the requested attributes
    * `UPDATE_REQUIRED`: The service needs to be updated to support
      the requested attributes
    """

    __schema__ = schema
    __choices__ = (
        "DATA_STORE_NOT_SUPPORTED",
        "NEW_CONNECTIONS_NOT_SUPPORTED",
        "REMOTE_AGENT_NOT_SUPPORTED",
        "SUPPORTED",
        "UPDATE_REQUIRED",
    )


class PlatformTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AWS`None
    * `AWS_GENERIC`None
    * `AWS_PROXIED`None
    * `AZURE`None
    * `GCP`None
    * `GCP_PROXIED`None
    * `GENERIC`None
    * `SNOWFLAKE`None
    """

    __schema__ = schema
    __choices__ = (
        "AWS",
        "AWS_GENERIC",
        "AWS_PROXIED",
        "AZURE",
        "GCP",
        "GCP_PROXIED",
        "GENERIC",
        "SNOWFLAKE",
    )


class PowerBIAuthModeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `PRIMARY_USER`None
    * `SERVICE_PRINCIPAL`None
    """

    __schema__ = schema
    __choices__ = ("PRIMARY_USER", "SERVICE_PRINCIPAL")


class PowerBIAuthModeEnumV2(sgqlc.types.Enum):
    """Enumeration Choices:

    * `PRIMARY_USER`None
    * `SERVICE_PRINCIPAL`None
    """

    __schema__ = schema
    __choices__ = ("PRIMARY_USER", "SERVICE_PRINCIPAL")


class PowerBIUpdateAuthModeEnumV2(sgqlc.types.Enum):
    """Enumeration Choices:

    * `PRIMARY_USER`None
    * `SERVICE_PRINCIPAL`None
    """

    __schema__ = schema
    __choices__ = ("PRIMARY_USER", "SERVICE_PRINCIPAL")


class PredicateArity(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BINARY`None
    * `UNARY`None
    """

    __schema__ = schema
    __choices__ = ("BINARY", "UNARY")


class PredicateRequiredType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ANY`None
    * `DATE`None
    * `REGEX`None
    * `TEXT`None
    * `TIMESTAMP`None
    """

    __schema__ = schema
    __choices__ = ("ANY", "DATE", "REGEX", "TEXT", "TIMESTAMP")


class Priority(sgqlc.types.Enum):
    """Enumeration Choices:

    * `P1`None
    * `P2`None
    * `P3`None
    * `P4`None
    * `P5`None
    """

    __schema__ = schema
    __choices__ = ("P1", "P2", "P3", "P4", "P5")


class Provider(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AZURE_DEVOPS`None
    * `GITHUB`None
    * `GITLAB`None
    """

    __schema__ = schema
    __choices__ = ("AZURE_DEVOPS", "GITHUB", "GITLAB")


class ProvisioningSchema(sgqlc.types.Enum):
    """Schema version for this auth provisioning configuration.

    Enumeration Choices:

    * `SCIM_V2`None
    """

    __schema__ = schema
    __choices__ = ("SCIM_V2",)


class PullRequestFilterName(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AUTHOR`None
    * `FILE_PATH`None
    * `FULL_REPO`None
    * `REPO`None
    * `TEXT_SEARCH`None
    """

    __schema__ = schema
    __choices__ = ("AUTHOR", "FILE_PATH", "FULL_REPO", "REPO", "TEXT_SEARCH")


class QueryCategory(sgqlc.types.Enum):
    """Possible query categories

    Enumeration Choices:

    * `alter`None
    * `clone`None
    * `copy`None
    * `create_table`None
    * `create_table_as_select`None
    * `create_table_using_template`None
    * `create_view`None
    * `delete_from`None
    * `delete_using`None
    * `drop_table`None
    * `explain`None
    * `insert_into`None
    * `insert_overwrite`None
    * `load`None
    * `merge`None
    * `put`None
    * `query`None
    * `rename`None
    * `select_into`None
    * `swap`None
    * `truncate`None
    * `unload`None
    * `update`None
    """

    __schema__ = schema
    __choices__ = (
        "alter",
        "clone",
        "copy",
        "create_table",
        "create_table_as_select",
        "create_table_using_template",
        "create_view",
        "delete_from",
        "delete_using",
        "drop_table",
        "explain",
        "insert_into",
        "insert_overwrite",
        "load",
        "merge",
        "put",
        "query",
        "rename",
        "select_into",
        "swap",
        "truncate",
        "unload",
        "update",
    )


class QueryLogType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `READ`None
    * `WRITE`None
    """

    __schema__ = schema
    __choices__ = ("READ", "WRITE")


class QueryRcaType(sgqlc.types.Enum):
    """Types of query RCAs

    Enumeration Choices:

    * `AFR`None
    * `DBT_FAIL_SKIP`None
    * `EMPTY`None
    * `FAILED`None
    * `NEW`None
    * `QDR`None
    * `UPDATE`None
    * `UPSTREAM`None
    """

    __schema__ = schema
    __choices__ = ("AFR", "DBT_FAIL_SKIP", "EMPTY", "FAILED", "NEW", "QDR", "UPDATE", "UPSTREAM")


class QueryResultType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `LABELED_NUMERICS`None
    * `ROWS`None
    * `ROW_COUNT`None
    * `SINGLE_NUMERIC`None
    * `UNIQUE_ROW_COUNT`None
    * `UNIQUE_VALUE_LIST`None
    * `VALUE_LIST`None
    """

    __schema__ = schema
    __choices__ = (
        "LABELED_NUMERICS",
        "ROWS",
        "ROW_COUNT",
        "SINGLE_NUMERIC",
        "UNIQUE_ROW_COUNT",
        "UNIQUE_VALUE_LIST",
        "VALUE_LIST",
    )


class QueryType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `read`: Filter for reads on the table
    * `write`: Filter for writes to the table
    """

    __schema__ = schema
    __choices__ = ("read", "write")


class RcaJobsModelJobType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DELTA_HISTORY_SAMPLING`: Delta History sampling
    * `FIELD_QUALITY_CORRELATION`: Field Quality Rule value
      correlation
    * `METRIC_CORRELATION`: Metric (Field Health) value correlation
    * `NUMERIC_CORRELATION`: Numeric (Field Health) value correlation
    * `SIZE_DIFF_CORRELATION`: Size Diff value correlation
    * `SIZE_DIFF_SAMPLING`: Size Diff sampling
    * `SQL_RULE_BREACH_SAMPLING`: SQL rule breach sampling
    * `SQL_RULE_CUSTOM_SAMPLING`: Custom SQL monitor custom sampling
    * `SQL_RULE_PROFILING`: Custom SQL monitor sample data profiling
    """

    __schema__ = schema
    __choices__ = (
        "DELTA_HISTORY_SAMPLING",
        "FIELD_QUALITY_CORRELATION",
        "METRIC_CORRELATION",
        "NUMERIC_CORRELATION",
        "SIZE_DIFF_CORRELATION",
        "SIZE_DIFF_SAMPLING",
        "SQL_RULE_BREACH_SAMPLING",
        "SQL_RULE_CUSTOM_SAMPLING",
        "SQL_RULE_PROFILING",
    )


class RcaJobsModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CANCELED`: canceled
    * `EMPTY`: No root cause found
    * `EXPIRED`: expired
    * `FAILED`: RCA process has failed
    * `FOUND`: Root cause has been found
    * `PARTIAL_DATA`: partial_data
    """

    __schema__ = schema
    __choices__ = ("CANCELED", "EMPTY", "EXPIRED", "FAILED", "FOUND", "PARTIAL_DATA")


class RcaStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CANCELED`None
    * `EMPTY`None
    * `EXPIRED`None
    * `FAILED`None
    * `FOUND`None
    * `PARTIAL_DATA`None
    """

    __schema__ = schema
    __choices__ = ("CANCELED", "EMPTY", "EXPIRED", "FAILED", "FOUND", "PARTIAL_DATA")


class RelationshipType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXPERT`None
    * `OWNER`None
    """

    __schema__ = schema
    __choices__ = ("EXPERT", "OWNER")


class ReportStatusEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPLETED`None
    * `FAILED`None
    * `QUEUED`None
    * `RUNNING`None
    """

    __schema__ = schema
    __choices__ = ("COMPLETED", "FAILED", "QUEUED", "RUNNING")


class ReportTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALERTS_REPORT`None
    * `ASSETS_REPORT`None
    * `CONSUMPTION_REPORT`None
    * `EVENTS_REPORT`None
    * `LINEAGE_EDGES_REPORT`None
    * `MONITORS_REPORT`None
    """

    __schema__ = schema
    __choices__ = (
        "ALERTS_REPORT",
        "ASSETS_REPORT",
        "CONSUMPTION_REPORT",
        "EVENTS_REPORT",
        "LINEAGE_EDGES_REPORT",
        "MONITORS_REPORT",
    )


class ResponseMetadataType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `MONITOR_RECOMMENDATIONS`None
    * `QUERY_RESPONSE`None
    """

    __schema__ = schema
    __choices__ = ("MONITOR_RECOMMENDATIONS", "QUERY_RESPONSE")


class SamplingEnabledMetricTypes(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DUPLICATE_COUNT`None
    * `EMPTY_STRING_COUNT`None
    * `EMPTY_STRING_RATE`None
    * `FALSE_COUNT`None
    * `FALSE_RATE`None
    * `FUTURE_TIMESTAMP_COUNT`None
    * `FUTURE_TIMESTAMP_RATE`None
    * `NAN_COUNT`None
    * `NAN_RATE`None
    * `NEGATIVE_COUNT`None
    * `NEGATIVE_RATE`None
    * `NON_NULL_COUNT`None
    * `NULL_COUNT`None
    * `NULL_RATE`None
    * `NUMERIC_MAX`None
    * `NUMERIC_MEAN`None
    * `NUMERIC_MEDIAN`None
    * `NUMERIC_MIN`None
    * `NUMERIC_STDDEV`None
    * `PAST_TIMESTAMP_COUNT`None
    * `PAST_TIMESTAMP_RATE`None
    * `PERCENTILE_20`None
    * `PERCENTILE_40`None
    * `PERCENTILE_60`None
    * `PERCENTILE_80`None
    * `RELATIVE_ROW_COUNT`None
    * `ROW_COUNT_CHANGE`None
    * `SUM`None
    * `TEXT_ALL_SPACE_COUNT`None
    * `TEXT_ALL_SPACE_RATE`None
    * `TEXT_EMAIL_ADDRESS_RATE`None
    * `TEXT_INT_RATE`None
    * `TEXT_MAX_LENGTH`None
    * `TEXT_MEAN_LENGTH`None
    * `TEXT_MIN_LENGTH`None
    * `TEXT_NOT_EMAIL_ADDRESS_COUNT`None
    * `TEXT_NOT_INT_COUNT`None
    * `TEXT_NOT_NUMBER_COUNT`None
    * `TEXT_NOT_SSN_COUNT`None
    * `TEXT_NOT_TIMESTAMP_COUNT`None
    * `TEXT_NOT_US_PHONE_COUNT`None
    * `TEXT_NOT_US_STATE_CODE_COUNT`None
    * `TEXT_NOT_US_ZIP_CODE_COUNT`None
    * `TEXT_NOT_UUID_COUNT`None
    * `TEXT_NULL_KEYWORD_COUNT`None
    * `TEXT_NULL_KEYWORD_RATE`None
    * `TEXT_NUMBER_RATE`None
    * `TEXT_SSN_RATE`None
    * `TEXT_STD_LENGTH`None
    * `TEXT_TIMESTAMP_RATE`None
    * `TEXT_US_PHONE_RATE`None
    * `TEXT_US_STATE_CODE_RATE`None
    * `TEXT_US_ZIP_CODE_RATE`None
    * `TEXT_UUID_RATE`None
    * `TIME_SINCE_LAST_ROW_COUNT_CHANGE`None
    * `TRUE_COUNT`None
    * `TRUE_RATE`None
    * `UNIQUE_COUNT`None
    * `UNIQUE_RATE`None
    * `UNIX_ZERO_COUNT`None
    * `UNIX_ZERO_RATE`None
    * `ZERO_COUNT`None
    * `ZERO_RATE`None
    """

    __schema__ = schema
    __choices__ = (
        "DUPLICATE_COUNT",
        "EMPTY_STRING_COUNT",
        "EMPTY_STRING_RATE",
        "FALSE_COUNT",
        "FALSE_RATE",
        "FUTURE_TIMESTAMP_COUNT",
        "FUTURE_TIMESTAMP_RATE",
        "NAN_COUNT",
        "NAN_RATE",
        "NEGATIVE_COUNT",
        "NEGATIVE_RATE",
        "NON_NULL_COUNT",
        "NULL_COUNT",
        "NULL_RATE",
        "NUMERIC_MAX",
        "NUMERIC_MEAN",
        "NUMERIC_MEDIAN",
        "NUMERIC_MIN",
        "NUMERIC_STDDEV",
        "PAST_TIMESTAMP_COUNT",
        "PAST_TIMESTAMP_RATE",
        "PERCENTILE_20",
        "PERCENTILE_40",
        "PERCENTILE_60",
        "PERCENTILE_80",
        "RELATIVE_ROW_COUNT",
        "ROW_COUNT_CHANGE",
        "SUM",
        "TEXT_ALL_SPACE_COUNT",
        "TEXT_ALL_SPACE_RATE",
        "TEXT_EMAIL_ADDRESS_RATE",
        "TEXT_INT_RATE",
        "TEXT_MAX_LENGTH",
        "TEXT_MEAN_LENGTH",
        "TEXT_MIN_LENGTH",
        "TEXT_NOT_EMAIL_ADDRESS_COUNT",
        "TEXT_NOT_INT_COUNT",
        "TEXT_NOT_NUMBER_COUNT",
        "TEXT_NOT_SSN_COUNT",
        "TEXT_NOT_TIMESTAMP_COUNT",
        "TEXT_NOT_US_PHONE_COUNT",
        "TEXT_NOT_US_STATE_CODE_COUNT",
        "TEXT_NOT_US_ZIP_CODE_COUNT",
        "TEXT_NOT_UUID_COUNT",
        "TEXT_NULL_KEYWORD_COUNT",
        "TEXT_NULL_KEYWORD_RATE",
        "TEXT_NUMBER_RATE",
        "TEXT_SSN_RATE",
        "TEXT_STD_LENGTH",
        "TEXT_TIMESTAMP_RATE",
        "TEXT_US_PHONE_RATE",
        "TEXT_US_STATE_CODE_RATE",
        "TEXT_US_ZIP_CODE_RATE",
        "TEXT_UUID_RATE",
        "TIME_SINCE_LAST_ROW_COUNT_CHANGE",
        "TRUE_COUNT",
        "TRUE_RATE",
        "UNIQUE_COUNT",
        "UNIQUE_RATE",
        "UNIX_ZERO_COUNT",
        "UNIX_ZERO_RATE",
        "ZERO_COUNT",
        "ZERO_RATE",
    )


class ScheduleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DYNAMIC`None
    * `FIXED`None
    * `LOOSE`None
    * `MANUAL`None
    """

    __schema__ = schema
    __choices__ = ("DYNAMIC", "FIXED", "LOOSE", "MANUAL")


class SearchCategoryEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALL_OTHER_TABLES`None
    * `RESOLVED_TABLES`None
    """

    __schema__ = schema
    __choices__ = ("ALL_OTHER_TABLES", "RESOLVED_TABLES")


class SegmentationType(sgqlc.types.Enum):
    """Defines different types of segmentation types

    Enumeration Choices:

    * `CUSTOM_SQL_EXPRESSION`None
    * `FIELD`None
    """

    __schema__ = schema
    __choices__ = ("CUSTOM_SQL_EXPRESSION", "FIELD")


class SelfHostedCredentialsTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AWS_SECRETS_MANAGER`None
    * `AZURE_KEY_VAULT`None
    * `ENV_VAR`None
    * `GCP_SECRET_MANAGER`None
    """

    __schema__ = schema
    __choices__ = ("AWS_SECRETS_MANAGER", "AZURE_KEY_VAULT", "ENV_VAR", "GCP_SECRET_MANAGER")


class SelfHostedUpdateCredentialsTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AWS_SECRETS_MANAGER`None
    * `ENV_VAR`None
    """

    __schema__ = schema
    __choices__ = ("AWS_SECRETS_MANAGER", "ENV_VAR")


class SensitivityLevels(sgqlc.types.Enum):
    """Enumeration Choices:

    * `HIGH`None
    * `LOW`None
    * `MEDIUM`None
    """

    __schema__ = schema
    __choices__ = ("HIGH", "LOW", "MEDIUM")


class ServiceNowCredentialsType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `OAUTH_CLIENT_CREDENTIALS`None
    * `USERNAME_PASSWORD`None
    """

    __schema__ = schema
    __choices__ = ("OAUTH_CLIENT_CREDENTIALS", "USERNAME_PASSWORD")


class Severity(sgqlc.types.Enum):
    """Enumeration Choices:

    * `SEV_1`None
    * `SEV_2`None
    * `SEV_3`None
    * `SEV_4`None
    """

    __schema__ = schema
    __choices__ = ("SEV_1", "SEV_2", "SEV_3", "SEV_4")


class SeverityInput(sgqlc.types.Enum):
    """Enumeration Choices:

    * `NO_SEVERITY`None
    * `SEV_1`None
    * `SEV_2`None
    * `SEV_3`None
    * `SEV_4`None
    """

    __schema__ = schema
    __choices__ = ("NO_SEVERITY", "SEV_1", "SEV_2", "SEV_3", "SEV_4")


class SharedQueryTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `PERMANENT`None
    * `TEMPORARY`None
    """

    __schema__ = schema
    __choices__ = ("PERMANENT", "TEMPORARY")


class SlackAppType(sgqlc.types.Enum):
    """Defines different types of Slack apps

    Enumeration Choices:

    * `DISCOVER`None
    * `OBSERVE`None
    """

    __schema__ = schema
    __choices__ = ("DISCOVER", "OBSERVE")


class SlackCredentialsV2ModelSlackAppType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DISCOVER`: discover
    * `OBSERVE`: observe
    """

    __schema__ = schema
    __choices__ = ("DISCOVER", "OBSERVE")


class SlackEngagementEventType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CHANNEL_COMMENT`None
    * `REACTION_ADDED`None
    * `REACTION_REMOVED`None
    * `THREAD_REPLY`None
    """

    __schema__ = schema
    __choices__ = ("CHANNEL_COMMENT", "REACTION_ADDED", "REACTION_REMOVED", "THREAD_REPLY")


class SqlDialect(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ATHENA`None
    * `BIGQUERY`None
    * `CLICKHOUSE`None
    * `DATABRICKS`None
    * `DB2`None
    * `DREMIO`None
    * `HIVE`None
    * `MARIADB`None
    * `MOTHERDUCK`None
    * `MYSQL`None
    * `ORACLE`None
    * `POSTGRES`None
    * `PRESTO`None
    * `REDSHIFT`None
    * `SALESFORCE_CRM`None
    * `SALESFORCE_DATA_CLOUD`None
    * `SAPHANA`None
    * `SNOWFLAKE`None
    * `SPARK`None
    * `SQL_SERVER`None
    * `STARBURST_ENTERPRISE`None
    * `STARBURST_GALAXY`None
    * `TERADATA`None
    * `TSQL`None
    * `UNKNOWN`None
    """

    __schema__ = schema
    __choices__ = (
        "ATHENA",
        "BIGQUERY",
        "CLICKHOUSE",
        "DATABRICKS",
        "DB2",
        "DREMIO",
        "HIVE",
        "MARIADB",
        "MOTHERDUCK",
        "MYSQL",
        "ORACLE",
        "POSTGRES",
        "PRESTO",
        "REDSHIFT",
        "SALESFORCE_CRM",
        "SALESFORCE_DATA_CLOUD",
        "SAPHANA",
        "SNOWFLAKE",
        "SPARK",
        "SQL_SERVER",
        "STARBURST_ENTERPRISE",
        "STARBURST_GALAXY",
        "TERADATA",
        "TSQL",
        "UNKNOWN",
    )


class SqlJobCheckpointStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXECUTING_COMPLETE`None
    * `EXECUTING_START`None
    * `HAS_ERROR`None
    * `PROCESSING_COMPLETE`None
    * `PROCESSING_START`None
    * `REGISTERED`None
    """

    __schema__ = schema
    __choices__ = (
        "EXECUTING_COMPLETE",
        "EXECUTING_START",
        "HAS_ERROR",
        "PROCESSING_COMPLETE",
        "PROCESSING_START",
        "REGISTERED",
    )


class State(sgqlc.types.Enum):
    """Enumeration Choices:

    * `APPLIED`None
    * `FAILED`None
    * `PENDING`None
    * `SKIPPED`None
    """

    __schema__ = schema
    __choices__ = ("APPLIED", "FAILED", "PENDING", "SKIPPED")


class StatementOption(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALL_ACCOUNT_OWNERS`None
    * `SPECIFIC_ADDRESSES`None
    """

    __schema__ = schema
    __choices__ = ("ALL_ACCOUNT_OWNERS", "SPECIFIC_ADDRESSES")


class Status(sgqlc.types.Enum):
    """Access Request status

    Enumeration Choices:

    * `NOTIFIED`None
    * `PENDING`None
    * `RESOLVED`None
    """

    __schema__ = schema
    __choices__ = ("NOTIFIED", "PENDING", "RESOLVED")


class StorageEncryptionType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AMAZON_S3_SSE`None
    * `MONTE_CARLO_KMS`None
    """

    __schema__ = schema
    __choices__ = ("AMAZON_S3_SSE", "MONTE_CARLO_KMS")


class StorageTypeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AZURE_BLOB`None
    * `GCS`None
    * `S3`None
    * `S3_COMPATIBLE`None
    * `SNOWFLAKE_INTERNAL_STAGE`None
    """

    __schema__ = schema
    __choices__ = ("AZURE_BLOB", "GCS", "S3", "S3_COMPATIBLE", "SNOWFLAKE_INTERNAL_STAGE")


class StreamingClusterModelClusterType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CONFLUENT_KAFKA`: Confluent Kafka
    * `CONFLUENT_KAFKA_CONNECT`: Confluent Kafka Connect
    * `MSK_KAFKA`: MSK Kafka
    * `MSK_KAFKA_CONNECT`: MSK Kafka Connect
    * `SELF_HOSTED_KAFKA`: Self Hosted Kafka
    * `SELF_HOSTED_KAFKA_CONNECT`: Self Hosted Kafka Connect
    """

    __schema__ = schema
    __choices__ = (
        "CONFLUENT_KAFKA",
        "CONFLUENT_KAFKA_CONNECT",
        "MSK_KAFKA",
        "MSK_KAFKA_CONNECT",
        "SELF_HOSTED_KAFKA",
        "SELF_HOSTED_KAFKA_CONNECT",
    )


class StreamingSystemModelType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CONFLUENT_CLOUD`: Confluent Cloud
    * `MSK`: MSK
    * `SELF_HOSTED`: Self Hosted
    """

    __schema__ = schema
    __choices__ = ("CONFLUENT_CLOUD", "MSK", "SELF_HOSTED")


String = sgqlc.types.String


class TableAnomalyModelReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT`: Agent Anomaly
    * `COMPARISON_RULE`: Comparison Rule Anomaly
    * `CUSTOM_RULE`: Custom Rule Anomaly
    * `DIST`: Distribution Anomaly
    * `FRESHNESS`: Freshness Anomaly
    * `METRIC`: Metric Anomaly
    * `METRIC_COMPARISON`: Metric Comparison Anomaly
    * `QUERY_PERFORMANCE`: Query Performance Anomaly
    * `QUERY_RUNTIME`: Query Time Anomaly
    * `RULE_RUN_FAILURE`: Rule Run Failure Anomaly
    * `SIZE`: Size Anomaly
    * `SIZE_DIFF`: Row count anomaly
    * `UNCHANGED_SIZE`: Unchanged Size Anomaly
    """

    __schema__ = schema
    __choices__ = (
        "AGENT",
        "COMPARISON_RULE",
        "CUSTOM_RULE",
        "DIST",
        "FRESHNESS",
        "METRIC",
        "METRIC_COMPARISON",
        "QUERY_PERFORMANCE",
        "QUERY_RUNTIME",
        "RULE_RUN_FAILURE",
        "SIZE",
        "SIZE_DIFF",
        "UNCHANGED_SIZE",
    )


class TableFlagType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DEPRECATION`None
    * `WARNING`None
    """

    __schema__ = schema
    __choices__ = ("DEPRECATION", "WARNING")


class TableMonitorMetricType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `TABLES_WITHOUT_MONITORS_COUNT`None
    * `TABLES_WITH_MONITORS_COUNT`None
    * `TOTAL_MONITORS_COUNT`None
    * `TOTAL_TABLES_COUNT`None
    """

    __schema__ = schema
    __choices__ = (
        "TABLES_WITHOUT_MONITORS_COUNT",
        "TABLES_WITH_MONITORS_COUNT",
        "TOTAL_MONITORS_COUNT",
        "TOTAL_TABLES_COUNT",
    )


class TableMonitorModelPriority(sgqlc.types.Enum):
    """Enumeration Choices:

    * `P1`: P1
    * `P2`: P2
    * `P3`: P3
    * `P4`: P4
    * `P5`: P5
    """

    __schema__ = schema
    __choices__ = ("P1", "P2", "P3", "P4", "P5")


class TableType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DYNAMIC`None
    * `EXTERNAL`None
    * `SNAPSHOT`None
    * `SNOWFLAKE_STREAM`None
    * `TABLE`None
    * `VECTOR_INDEX`None
    * `VIEW`None
    * `WILDCARD_TABLE`None
    """

    __schema__ = schema
    __choices__ = (
        "DYNAMIC",
        "EXTERNAL",
        "SNAPSHOT",
        "SNOWFLAKE_STREAM",
        "TABLE",
        "VECTOR_INDEX",
        "VIEW",
        "WILDCARD_TABLE",
    )


class TagAssignmentObjectType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CUSTOM_RULE_MONITOR`None
    * `METRIC_MONITOR`None
    * `TABLE_MONITOR`None
    """

    __schema__ = schema
    __choices__ = ("CUSTOM_RULE_MONITOR", "METRIC_MONITOR", "TABLE_MONITOR")


class TagType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DATA_QUALITY_DIMENSION_TAG`None
    * `MONITOR_TAG`None
    """

    __schema__ = schema
    __choices__ = ("DATA_QUALITY_DIMENSION_TAG", "MONITOR_TAG")


class TasksPerformanceSummarySort(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AVG_RUN_DURATION`None
    * `DISPLAY_NAME`None
    * `FAILURE_RATE`None
    * `INTEGRATION_TYPE`None
    * `LAST_RUN_END_TIME`None
    * `LAST_RUN_START_TIME`None
    * `LAST_RUN_STATUS`None
    * `LAST_RUN_UUID`None
    * `MCON`None
    * `RUN_COUNT`None
    * `RUN_DURATION_TREND_7D`None
    """

    __schema__ = schema
    __choices__ = (
        "AVG_RUN_DURATION",
        "DISPLAY_NAME",
        "FAILURE_RATE",
        "INTEGRATION_TYPE",
        "LAST_RUN_END_TIME",
        "LAST_RUN_START_TIME",
        "LAST_RUN_STATUS",
        "LAST_RUN_UUID",
        "MCON",
        "RUN_COUNT",
        "RUN_DURATION_TREND_7D",
    )


class TeradataLogMechEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BROWSER`None
    * `JWT`None
    * `KRB5`None
    * `LDAP`None
    * `TD2`None
    * `TDNEGO`None
    """

    __schema__ = schema
    __choices__ = ("BROWSER", "JWT", "KRB5", "LDAP", "TD2", "TDNEGO")


class TeradataLogMechUpdateEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BROWSER`None
    * `JWT`None
    * `KRB5`None
    * `LDAP`None
    * `TD2`None
    * `TDNEGO`None
    """

    __schema__ = schema
    __choices__ = ("BROWSER", "JWT", "KRB5", "LDAP", "TD2", "TDNEGO")


class TeradataSSLModeEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALLOW`None
    * `DISABLE`None
    * `PREFER`None
    * `REQUIRE`None
    * `VERIFY_CA`None
    * `VERIFY_FULL`None
    """

    __schema__ = schema
    __choices__ = ("ALLOW", "DISABLE", "PREFER", "REQUIRE", "VERIFY_CA", "VERIFY_FULL")


class TeradataSSLModeUpdateEnum(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ALLOW`None
    * `DISABLE`None
    * `PREFER`None
    * `REQUIRE`None
    * `VERIFY_CA`None
    * `VERIFY_FULL`None
    """

    __schema__ = schema
    __choices__ = ("ALLOW", "DISABLE", "PREFER", "REQUIRE", "VERIFY_CA", "VERIFY_FULL")


class ThresholdModifierType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `METRIC`None
    * `PERCENTAGE`None
    """

    __schema__ = schema
    __choices__ = ("METRIC", "PERCENTAGE")


class ThresholdStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACTIVE`None
    * `INACTIVE`None
    * `TRAINING`None
    """

    __schema__ = schema
    __choices__ = ("ACTIVE", "INACTIVE", "TRAINING")


class ThresholdType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `COMPARISON`None
    * `CUSTOM`None
    * `FIELD_HEALTH`None
    * `FRESHNESS`None
    * `ROWS`None
    * `SIZE_DIFF`None
    * `UNCHANGED_SIZE`None
    * `VOLUME_CHANGE`None
    """

    __schema__ = schema
    __choices__ = (
        "COMPARISON",
        "CUSTOM",
        "FIELD_HEALTH",
        "FRESHNESS",
        "ROWS",
        "SIZE_DIFF",
        "UNCHANGED_SIZE",
        "VOLUME_CHANGE",
    )


class TimeBucketSize(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DAY`None
    * `HOUR`None
    """

    __schema__ = schema
    __choices__ = ("DAY", "HOUR")


class TimeRangeUnit(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DAY`None
    * `MONTH`None
    * `WEEK`None
    """

    __schema__ = schema
    __choices__ = ("DAY", "MONTH", "WEEK")


class TraceFilterFieldName(sgqlc.types.Enum):
    """Field names for trace filters.

    Enumeration Choices:

    * `COMPLETION_TOKENS`None
    * `DURATION`None
    * `MODEL`None
    * `PROMPT_TOKENS`None
    * `TASK`None
    * `TOTAL_TOKENS`None
    * `WORKFLOW`None
    """

    __schema__ = schema
    __choices__ = (
        "COMPLETION_TOKENS",
        "DURATION",
        "MODEL",
        "PROMPT_TOKENS",
        "TASK",
        "TOTAL_TOKENS",
        "WORKFLOW",
    )


class TraceSortDirection(sgqlc.types.Enum):
    """Sort direction for traces.

    Enumeration Choices:

    * `ASC`None
    * `DESC`None
    """

    __schema__ = schema
    __choices__ = ("ASC", "DESC")


class TraceSortField(sgqlc.types.Enum):
    """Fields that can be used for sorting traces.

    Enumeration Choices:

    * `COMPLETION_TOKENS`None
    * `COUNT_LLM_CALLS`None
    * `DURATION_SECONDS`None
    * `PROMPT_TOKENS`None
    * `TOTAL_TOKENS`None
    * `TRACE_END_TIME`None
    * `TRACE_ID`None
    * `TRACE_START_TIME`None
    """

    __schema__ = schema
    __choices__ = (
        "COMPLETION_TOKENS",
        "COUNT_LLM_CALLS",
        "DURATION_SECONDS",
        "PROMPT_TOKENS",
        "TOTAL_TOKENS",
        "TRACE_END_TIME",
        "TRACE_ID",
        "TRACE_START_TIME",
    )


class TutorialStatusType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `completed`None
    * `initial`None
    * `invalid`None
    * `started`None
    """

    __schema__ = schema
    __choices__ = ("completed", "initial", "invalid", "started")


class UUID(sgqlc.types.Scalar):
    """Leverages the internal Python implmeentation of UUID (uuid.UUID)
    to provide native UUID objects in fields, resolvers and input.
    """

    __schema__ = schema


class UnifiedUserAssignmentModelRelationshipType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `EXPERT`: Expert
    * `OWNER`: Owner
    """

    __schema__ = schema
    __choices__ = ("EXPERT", "OWNER")


class Upload(sgqlc.types.Scalar):
    """Create scalar that ignores normal serialization/deserialization,
    since that will be handled by the multipart request spec
    """

    __schema__ = schema


class UserDefinedMonitorModelBreached(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BREACHED`: BREACHED
    * `NOT_BREACHED`: NOT_BREACHED
    """

    __schema__ = schema
    __choices__ = ("BREACHED", "NOT_BREACHED")


class UserDefinedMonitorModelConsolidatedMonitorStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DISABLED`: DISABLED
    * `DRAFT`: DRAFT
    * `ENABLED`: ENABLED
    * `ERROR`: ERROR
    * `INSUFFICIENT_DATA`: INSUFFICIENT_DATA
    * `SNOOZED`: SNOOZED
    * `TRAINING`: TRAINING
    """

    __schema__ = schema
    __choices__ = (
        "DISABLED",
        "DRAFT",
        "ENABLED",
        "ERROR",
        "INSUFFICIENT_DATA",
        "SNOOZED",
        "TRAINING",
    )


class UserDefinedMonitorModelMonitorType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT`: Agent
    * `CATEGORIES`: Dimension
    * `COMPARISON`: Comparison
    * `CUSTOM_SQL`: Custom SQL
    * `FIELD_QUALITY`: Metric - legacy
    * `FRESHNESS`: Freshness
    * `HOURLY_STATS`: Statistical metrics over an hour interval
    * `JSON_SCHEMA`: JSON schema
    * `METRIC_COMPARISON`: Comparison
    * `QUERY_PERF`: Query performance
    * `STATS`: Metric
    * `TABLE_METRIC`: Table metric rule
    * `VALIDATION`: Validation
    * `VOLUME`: Volume
    """

    __schema__ = schema
    __choices__ = (
        "AGENT",
        "CATEGORIES",
        "COMPARISON",
        "CUSTOM_SQL",
        "FIELD_QUALITY",
        "FRESHNESS",
        "HOURLY_STATS",
        "JSON_SCHEMA",
        "METRIC_COMPARISON",
        "QUERY_PERF",
        "STATS",
        "TABLE_METRIC",
        "VALIDATION",
        "VOLUME",
    )


class UserDefinedMonitorModelScheduleType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DYNAMIC`: Dynamic
    * `FIXED`: Fixed
    * `LOOSE`: Loose
    * `MANUAL`: Manual
    """

    __schema__ = schema
    __choices__ = ("DYNAMIC", "FIXED", "LOOSE", "MANUAL")


class UserDefinedMonitorModelSegmentationType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CUSTOM_SQL_EXPRESSION`: custom_sql_expression
    * `FIELD`: field
    """

    __schema__ = schema
    __choices__ = ("CUSTOM_SQL_EXPRESSION", "FIELD")


class UserDefinedMonitorModelUdmType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `MONITOR`: MONITOR
    * `RULE`: RULE
    """

    __schema__ = schema
    __choices__ = ("MONITOR", "RULE")


class UserDefinedMonitorSearchFields(sgqlc.types.Enum):
    """Defines which fields can be used for full text search in the user
    defined monitors view

    Enumeration Choices:

    * `CREATOR_ID`None
    * `ENTITIES`None
    * `MONITOR_FIELDS`None
    * `NAMESPACE`None
    * `RULE_DESCRIPTION`None
    * `RULE_NAME`None
    * `UPDATER_ID`None
    """

    __schema__ = schema
    __choices__ = (
        "CREATOR_ID",
        "ENTITIES",
        "MONITOR_FIELDS",
        "NAMESPACE",
        "RULE_DESCRIPTION",
        "RULE_NAME",
        "UPDATER_ID",
    )


class UserDefinedMonitors(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AGENT`: Agent
    * `CATEGORIES`: Dimension - legacy
    * `COMPARISON`: Comparison - legacy
    * `CUSTOM_SQL`: Custom SQL
    * `FIELD_QUALITY`: Metric - legacy
    * `FRESHNESS`: Freshness
    * `JSON_SCHEMA`: JSON schema
    * `METRIC_COMPARISON`: Comparison
    * `QUERY_PERF`: Query performance
    * `SCHEMA`: Schema
    * `STATS`: Metric
    * `TABLE`: Table
    * `TABLE_METRIC`: Volume - legacy
    * `VALIDATION`: Validation
    * `VOLUME`: Volume
    """

    __schema__ = schema
    __choices__ = (
        "AGENT",
        "CATEGORIES",
        "COMPARISON",
        "CUSTOM_SQL",
        "FIELD_QUALITY",
        "FRESHNESS",
        "JSON_SCHEMA",
        "METRIC_COMPARISON",
        "QUERY_PERF",
        "SCHEMA",
        "STATS",
        "TABLE",
        "TABLE_METRIC",
        "VALIDATION",
        "VOLUME",
    )


class UserInviteModelInviteType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `OBSERVABILITY`: observability
    """

    __schema__ = schema
    __choices__ = ("OBSERVABILITY",)


class UserInviteModelState(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACCEPTED`: Accepted
    * `INVALIDATED`: Invalidated
    * `SENT`: Sent
    """

    __schema__ = schema
    __choices__ = ("ACCEPTED", "INVALIDATED", "SENT")


class UserModelDeleteReason(sgqlc.types.Enum):
    """Enumeration Choices:

    * `ACCOUNT_DEACTIVATED`: account deactivated
    * `DEACTIVATED_BY_SCIM_REQUEST`: deactivated through SCIM request
    * `DELETED_BY_MC`: deleted by MC admin
    * `DELETED_BY_USER`: deleted by user
    """

    __schema__ = schema
    __choices__ = (
        "ACCOUNT_DEACTIVATED",
        "DEACTIVATED_BY_SCIM_REQUEST",
        "DELETED_BY_MC",
        "DELETED_BY_USER",
    )


class UserModelPersona(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AI_ENGINEER`: ai_engineer
    * `BI_ANALYST_ENGINEER`: bi_analyst_or_engineer
    * `DATA_ANALYST`: data_analyst
    * `DATA_ENGINEER`: data_engineer
    * `DATA_SCIENTIST`: data_scientist
    * `EARLY_USER`: early_user
    * `EXECUTIVE`: executive
    * `OTHER`: other
    * `PRODUCT_MANAGER_OWNER`: product_manager_or_owner
    * `SOFTWARE_ENGINEER`: software_engineer
    * `TEAM_LEAD`: team_lead
    """

    __schema__ = schema
    __choices__ = (
        "AI_ENGINEER",
        "BI_ANALYST_ENGINEER",
        "DATA_ANALYST",
        "DATA_ENGINEER",
        "DATA_SCIENTIST",
        "EARLY_USER",
        "EXECUTIVE",
        "OTHER",
        "PRODUCT_MANAGER_OWNER",
        "SOFTWARE_ENGINEER",
        "TEAM_LEAD",
    )


class UserModelState(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CHECK_BACK`: Check Back Soon
    * `CONNECT_DW`: Connect Data Warehouse
    * `DASHBOARD`: View Dashboard
    * `INSTALL_DC`: Install Data Collector
    * `INTEGRATIONS`: Other integrations
    * `INVITE_USERS`: Invite Users
    * `NOT_AVAILABLE`: Not available
    * `SET_ACCOUNT_NAME`: Set Account Name
    * `SIGNED_UP`: Signed-Up
    """

    __schema__ = schema
    __choices__ = (
        "CHECK_BACK",
        "CONNECT_DW",
        "DASHBOARD",
        "INSTALL_DC",
        "INTEGRATIONS",
        "INVITE_USERS",
        "NOT_AVAILABLE",
        "SET_ACCOUNT_NAME",
        "SIGNED_UP",
    )


class UserPersona(sgqlc.types.Enum):
    """Enumeration Choices:

    * `AI_ENGINEER`None
    * `BI_ANALYST_ENGINEER`None
    * `DATA_ANALYST`None
    * `DATA_ENGINEER`None
    * `DATA_SCIENTIST`None
    * `EARLY_USER`None
    * `EXECUTIVE`None
    * `OTHER`None
    * `PRODUCT_MANAGER_OWNER`None
    * `SOFTWARE_ENGINEER`None
    * `TEAM_LEAD`None
    """

    __schema__ = schema
    __choices__ = (
        "AI_ENGINEER",
        "BI_ANALYST_ENGINEER",
        "DATA_ANALYST",
        "DATA_ENGINEER",
        "DATA_SCIENTIST",
        "EARLY_USER",
        "EXECUTIVE",
        "OTHER",
        "PRODUCT_MANAGER_OWNER",
        "SOFTWARE_ENGINEER",
        "TEAM_LEAD",
    )


class WarehouseModelConnectionType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `BIGQUERY`: BigQuery
    * `CLICKHOUSE`: ClickHouse
    * `DATA_LAKE`: Data Lake
    * `DB2`: Db2
    * `DREMIO`: Dremio
    * `ETL`: etl
    * `MYSQL`: MySQL
    * `ORACLE`: Oracle
    * `PINECONE`: Pinecone
    * `REDSHIFT`: Amazon Redshift
    * `S3_METADATA_EVENTS`: S3 Metadata Events
    * `SALESFORCE_CRM`: salesforce-crm
    * `SALESFORCE_DATA_CLOUD`: Salesforce Data Cloud
    * `SNOWFLAKE`: Snowflake
    * `STARBURST_ENTERPRISE`: Starburst Enterprise
    * `STARBURST_GALAXY`: Starburst Galaxy
    * `TERADATA`: Teradata
    * `TRANSACTIONAL_DB`: Transactional DB
    """

    __schema__ = schema
    __choices__ = (
        "BIGQUERY",
        "CLICKHOUSE",
        "DATA_LAKE",
        "DB2",
        "DREMIO",
        "ETL",
        "MYSQL",
        "ORACLE",
        "PINECONE",
        "REDSHIFT",
        "S3_METADATA_EVENTS",
        "SALESFORCE_CRM",
        "SALESFORCE_DATA_CLOUD",
        "SNOWFLAKE",
        "STARBURST_ENTERPRISE",
        "STARBURST_GALAXY",
        "TERADATA",
        "TRANSACTIONAL_DB",
    )


class WarehouseRelationType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `CONSUMER`None
    * `PRODUCER`None
    """

    __schema__ = schema
    __choices__ = ("CONSUMER", "PRODUCER")


class WarehouseTableModelStatus(sgqlc.types.Enum):
    """Enumeration Choices:

    * `G`None
    * `R`None
    * `Y`None
    """

    __schema__ = schema
    __choices__ = ("G", "R", "Y")


class WebhookServiceTypes(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DATABRICKS`None
    * `GITLAB`None
    * `JIRA`None
    * `OPSGENIE`None
    * `PAGERDUTY`None
    * `SERVICENOW`None
    """

    __schema__ = schema
    __choices__ = ("DATABRICKS", "GITLAB", "JIRA", "OPSGENIE", "PAGERDUTY", "SERVICENOW")


class WebhookStatusValue(sgqlc.types.Enum):
    """Enum representing the status of webhook setup for an integration.

    Enumeration Choices:

    * `ACTIVE`None
    * `NEVER_RECEIVED`None
    * `STALE`None
    """

    __schema__ = schema
    __choices__ = ("ACTIVE", "NEVER_RECEIVED", "STALE")


class WidgetType(sgqlc.types.Enum):
    """Enumeration Choices:

    * `DISCRETE`None
    * `FIELD_PROFILE_TABLE_V2`None
    * `NUMERIC_DESCRIPTIVE_STATS`None
    * `TIMESTAMP_HISTOGRAM`None
    """

    __schema__ = schema
    __choices__ = (
        "DISCRETE",
        "FIELD_PROFILE_TABLE_V2",
        "NUMERIC_DESCRIPTIVE_STATS",
        "TIMESTAMP_HISTOGRAM",
    )


########################################################################
# Input Objects
########################################################################
class AIMessageInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("message", "actor", "mcons")
    message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message")
    """Message from the specified actor"""

    actor = sgqlc.types.Field(sgqlc.types.non_null(ActorType), graphql_name="actor")
    """The actor that sends the message"""

    mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="mcons")
    """The mcons for the tables added in this message"""


class AgentSpanFieldFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("value",)
    value = sgqlc.types.Field(String, graphql_name="value")


class AgentSpanFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("agent", "workflow", "task", "span_name")
    agent = sgqlc.types.Field(AgentSpanFieldFilterInput, graphql_name="agent")

    workflow = sgqlc.types.Field(AgentSpanFieldFilterInput, graphql_name="workflow")

    task = sgqlc.types.Field(AgentSpanFieldFilterInput, graphql_name="task")

    span_name = sgqlc.types.Field(AgentSpanFieldFilterInput, graphql_name="spanName")


class AggregateInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("by", "time_axis")
    by = sgqlc.types.Field(sgqlc.types.non_null(MonitorAggTimeInterval), graphql_name="by")
    """The aggregation time interval to use."""

    time_axis = sgqlc.types.Field(
        sgqlc.types.non_null("FilterValueUnionInput"), graphql_name="timeAxis"
    )
    """Time axis to group by"""


class AggregateMetricParams(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("aggregate_metric_type", "aggregate_metric_field_name", "alias")
    aggregate_metric_type = sgqlc.types.Field(
        sgqlc.types.non_null(AggregateMetricType), graphql_name="aggregateMetricType"
    )
    """Metric type"""

    aggregate_metric_field_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="aggregateMetricFieldName"
    )
    """Field to aggregate over"""

    alias = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="alias")
    """Alias to assign metric"""


class AirflowConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("host_name",)
    host_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="hostName")
    """Airflow host name"""


class AirflowEnvInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("env_name", "env_id", "version", "base_url")
    env_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="envName")
    """Environment name"""

    env_id = sgqlc.types.Field(String, graphql_name="envId")

    version = sgqlc.types.Field(String, graphql_name="version")

    base_url = sgqlc.types.Field(String, graphql_name="baseUrl")


class AlertsFilterCriteriaInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "types",
        "sub_types",
        "owners",
        "severities",
        "priorities",
        "statuses",
        "table_databases",
        "table_schemas",
        "table_ids",
        "table_mcons",
        "domain_id",
        "monitor_ids",
        "monitor_tags",
        "is_normalized",
        "has_jira_tickets",
        "has_service_now_incidents",
        "has_opsgenie_incidents",
        "has_datadog_incidents",
        "has_azure_devops_work_items",
        "has_key_assets",
        "tags",
        "audience_ids",
        "domain_ids",
        "data_product_ids",
    )
    types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertType)), graphql_name="types"
    )

    sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertSubType)), graphql_name="subTypes"
    )

    owners = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="owners")
    """Return alerts assigned to specified owners (by email)."""

    severities = sgqlc.types.Field(sgqlc.types.list_of(Severity), graphql_name="severities")

    priorities = sgqlc.types.Field(sgqlc.types.list_of(Priority), graphql_name="priorities")

    statuses = sgqlc.types.Field(sgqlc.types.list_of(AlertStatus), graphql_name="statuses")

    table_databases = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tableDatabases"
    )
    """Return alerts that involve tables that belong to the specified
    databases.
    """

    table_schemas = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tableSchemas"
    )
    """Return alerts that involve tables that belong to the specified
    schemas.
    """

    table_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tableIds"
    )
    """Return alerts that involve the specified tables."""

    table_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tableMcons"
    )
    """Return alerts that involve the specified tables."""

    domain_id = sgqlc.types.Field(UUID, graphql_name="domainId")

    monitor_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="monitorIds"
    )
    """Return alerts triggered by specified monitors."""

    monitor_tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="monitorTags"
    )
    """Return alerts triggered by monitors that have any of the specified
    tags.
    """

    is_normalized = sgqlc.types.Field(Boolean, graphql_name="isNormalized")
    """Normalized alerts are alerts where all associated events are in
    resolved state.If true, return only normalized alerts. If false,
    return only non-normalized alerts.
    """

    has_jira_tickets = sgqlc.types.Field(Boolean, graphql_name="hasJiraTickets")
    """If true, return only alerts with jira tickets. If false, return
    only alerts without any jira tickets.
    """

    has_service_now_incidents = sgqlc.types.Field(Boolean, graphql_name="hasServiceNowIncidents")
    """If true, return only alerts with ServiceNow incidents. If false,
    return only alerts without any ServiceNow incidents.
    """

    has_opsgenie_incidents = sgqlc.types.Field(Boolean, graphql_name="hasOpsgenieIncidents")
    """If true, return only alerts with Opsgenie incidents. If false,
    return only alerts without any Opsgenie incidents.
    """

    has_datadog_incidents = sgqlc.types.Field(Boolean, graphql_name="hasDatadogIncidents")
    """If true, return only alerts with Datadog incidents. If false,
    return only alerts without any Datadog incidents.
    """

    has_azure_devops_work_items = sgqlc.types.Field(Boolean, graphql_name="hasAzureDevopsWorkItems")
    """If true, return only alerts with Azure DevOps work items. If
    false, return only alerts without any Azure DevOps work items.
    """

    has_key_assets = sgqlc.types.Field(Boolean, graphql_name="hasKeyAssets")
    """If true, return only alerts associated with key assets.If false,
    return only alerts not associated with any key assets.
    """

    tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("TagKeyValuePairInput")), graphql_name="tags"
    )
    """Return alerts with the specified tags."""

    audience_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="audienceIds"
    )
    """Return alerts that notified specified audiences."""

    domain_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainIds"
    )

    data_product_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="dataProductIds"
    )
    """Return alerts that are on tables belong to these data products."""


class AlertsFilterDataFilterType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "value")
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsFilterFieldName), graphql_name="fieldName"
    )

    value = sgqlc.types.Field(GenericScalar, graphql_name="value")


class AlertsFilterDataRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "search_criteria", "first", "after", "search_value")
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsFilterFieldName), graphql_name="fieldName"
    )

    search_criteria = sgqlc.types.Field(
        sgqlc.types.non_null("AlertsFilterDataSearchCriteriaType"), graphql_name="searchCriteria"
    )

    first = sgqlc.types.Field(Int, graphql_name="first")
    """Number of results to return"""

    after = sgqlc.types.Field(String, graphql_name="after")
    """Cursor to paginate results"""

    search_value = sgqlc.types.Field(String, graphql_name="searchValue")
    """Respond with filter values which contain this text"""


class AlertsFilterDataSearchCriteriaType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("updated_time", "created_time", "filters")
    updated_time = sgqlc.types.Field("DateTimeRangeInput", graphql_name="updatedTime")
    """Supply a time range to filter alerts by their updated time. Either
    this or `createdTime` must be supplied.
    """

    created_time = sgqlc.types.Field("DateTimeRangeInput", graphql_name="createdTime")
    """Supply a time range to filter alerts by their created time. Either
    this or `updatedTime` must be supplied.
    """

    filters = sgqlc.types.Field(
        sgqlc.types.list_of(AlertsFilterDataFilterType), graphql_name="filters"
    )
    """List of filters to apply to alerts"""


class AlertsFilterExclusionCriteriaInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("types", "sub_types")
    types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertType)), graphql_name="types"
    )

    sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertSubType)), graphql_name="subTypes"
    )


class AlertsFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("include", "exclude")
    include = sgqlc.types.Field(AlertsFilterCriteriaInput, graphql_name="include")
    """Return alerts that match these conditions."""

    exclude = sgqlc.types.Field(AlertsFilterExclusionCriteriaInput, graphql_name="exclude")
    """Exclude alerts that match these conditions. Exclusion criteria
    overrides inclusion criteria.
    """


class ApiCallReference(sgqlc.types.Input):
    """References (For instance UUIDs) that were passed as input to
    GraphQL API calls
    """

    __schema__ = schema
    __field_names__ = ("parameter_name", "parameter_value", "parameter_values")
    parameter_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="parameterName")
    """Name of the parameter"""

    parameter_value = sgqlc.types.Field(String, graphql_name="parameterValue")
    """Value of the parameter. If provided, `parameter_values` will be
    ignored
    """

    parameter_values = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="parameterValues"
    )
    """List of values for the parameter"""


class AssetCollectionRuleConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("attribute_name", "value", "comparison_type")
    attribute_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="attributeName")
    """The name of the attribute to match"""

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """The value (or pattern) to compare the attribute against"""

    comparison_type = sgqlc.types.Field(
        CollectionPreferenceMatchType, graphql_name="comparisonType"
    )
    """The method for comparing the attribute to the given value"""


class AssetCollectionRuleInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("conditions", "effect")
    conditions = sgqlc.types.Field(
        sgqlc.types.list_of(AssetCollectionRuleConditionInput), graphql_name="conditions"
    )
    """The set of conditions that need to match in order for this rule to
    apply
    """

    effect = sgqlc.types.Field(AssetCollectionRuleEffect, graphql_name="effect")
    """Whether to allow or block the asset when this rule matches."""


class AssetFilterUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "table_name",
        "table_name_operator",
        "table_type",
        "table_tags",
        "table_tags_operator",
        "read_days",
        "write_days",
        "read_write_days",
        "volume_change_days",
        "read_activity_is_null",
        "write_activity_is_null",
        "read_write_activity_is_null",
        "type",
        "negated",
    )
    table_name = sgqlc.types.Field(String, graphql_name="tableName")

    table_name_operator = sgqlc.types.Field(
        AssetFilterTableNameOperator, graphql_name="tableNameOperator"
    )

    table_type = sgqlc.types.Field(TableType, graphql_name="tableType")

    table_tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tableTags"
    )

    table_tags_operator = sgqlc.types.Field(
        AssetFilterTableTagOperator, graphql_name="tableTagsOperator"
    )

    read_days = sgqlc.types.Field(Int, graphql_name="readDays")

    write_days = sgqlc.types.Field(Int, graphql_name="writeDays")

    read_write_days = sgqlc.types.Field(Int, graphql_name="readWriteDays")

    volume_change_days = sgqlc.types.Field(Int, graphql_name="volumeChangeDays")

    read_activity_is_null = sgqlc.types.Field(Boolean, graphql_name="readActivityIsNull")

    write_activity_is_null = sgqlc.types.Field(Boolean, graphql_name="writeActivityIsNull")

    read_write_activity_is_null = sgqlc.types.Field(Boolean, graphql_name="readWriteActivityIsNull")

    type = sgqlc.types.Field(sgqlc.types.non_null(AssetFilterType), graphql_name="type")

    negated = sgqlc.types.Field(Boolean, graphql_name="negated")


class AssetIncludeDatabaseInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "schemas")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    schemas = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="schemas"
    )


class AssetSelectionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("databases", "filters", "exclusions")
    databases = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AssetIncludeDatabaseInput)),
        graphql_name="databases",
    )

    filters = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AssetFilterUnionInput)), graphql_name="filters"
    )

    exclusions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AssetFilterUnionInput)), graphql_name="exclusions"
    )


class AssetsSortInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("sort_field", "sort_direction")
    sort_field = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sortField")
    """Field to sort by."""

    sort_direction = sgqlc.types.Field(AssetsSortDirection, graphql_name="sortDirection")
    """Sort direction. ASC or DESC, default is ASC"""


class AssetsUsageFilterOptions(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "only_ingested_tables",
        "only_not_ingested_tables",
        "only_monitored_tables",
        "only_not_monitored_tables",
        "only_ingested_schemas",
        "only_not_ingested_schemas",
        "only_ingested_databases",
        "only_not_ingested_databases",
    )
    only_ingested_tables = sgqlc.types.Field(Boolean, graphql_name="onlyIngestedTables")
    """To filter results that only has ingested tables."""

    only_not_ingested_tables = sgqlc.types.Field(Boolean, graphql_name="onlyNotIngestedTables")
    """To filter results that only does not have ingested tables."""

    only_monitored_tables = sgqlc.types.Field(Boolean, graphql_name="onlyMonitoredTables")
    """To filter results that only has monitored tables."""

    only_not_monitored_tables = sgqlc.types.Field(Boolean, graphql_name="onlyNotMonitoredTables")
    """To filter results that only does not have monitored tables."""

    only_ingested_schemas = sgqlc.types.Field(Boolean, graphql_name="onlyIngestedSchemas")
    """To filter results that only has ingested schemas."""

    only_not_ingested_schemas = sgqlc.types.Field(Boolean, graphql_name="onlyNotIngestedSchemas")
    """To filter results that only does not have ingested schemas."""

    only_ingested_databases = sgqlc.types.Field(Boolean, graphql_name="onlyIngestedDatabases")
    """To filter results that only has ingested databases."""

    only_not_ingested_databases = sgqlc.types.Field(
        Boolean, graphql_name="onlyNotIngestedDatabases"
    )
    """To filter results that only does not have ingested databases."""


class AudienceNotificationSettingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "recipients",
        "custom_display_names",
        "recipients_display_names",
        "notification_type",
        "extra",
        "audience_id",
        "integration_id",
        "uuid",
    )
    recipients = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="recipients"
    )
    """Destination to send notifications to"""

    custom_display_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="customDisplayNames"
    )
    """Display names for the recipients. If this input parameter is
    provided, it should contain an entry for each recipient in the
    same order as the `recipients` list
    """

    recipients_display_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="recipientsDisplayNames"
    )
    """Display names for the recipients. If this input parameter is
    provided, it should contain an entry for each recipient in the
    same order as the `recipients` list
    """

    notification_type = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="notificationType"
    )
    """Specify the notification integration to use. Supported options
    include: email, opsgenie, pagerduty, slack, slack_v2, google_chat,
    webhook, msteams, msteams_v2, alation, servicenow, jira, webex,
    incidentio, datadog, azure_devops
    """

    extra = sgqlc.types.Field("NotificationExtra", graphql_name="extra")
    """Any extra values"""

    audience_id = sgqlc.types.Field(UUID, graphql_name="audienceId")
    """Audience associated with the recipient"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Integration ID for the recipient"""

    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """For updating a notification setting"""


class AzureDataFactoryConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "tenant_id",
        "client_id",
        "client_secret",
        "subscription_id",
        "resource_group_name",
        "factory_name",
    )
    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")
    """Azure tenant id"""

    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")
    """Azure client id"""

    client_secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientSecret")
    """Azure client secret"""

    subscription_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="subscriptionId")
    """Azure subscription id"""

    resource_group_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="resourceGroupName"
    )
    """Azure resource group name"""

    factory_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="factoryName")
    """Azure Data Factory name"""


class AzureDataFactoryUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "tenant_id",
        "client_id",
        "client_secret",
        "subscription_id",
        "resource_group_name",
        "factory_name",
    )
    tenant_id = sgqlc.types.Field(String, graphql_name="tenantId")
    """Azure tenant id"""

    client_id = sgqlc.types.Field(String, graphql_name="clientId")
    """Azure client id"""

    client_secret = sgqlc.types.Field(String, graphql_name="clientSecret")
    """Azure client secret"""

    subscription_id = sgqlc.types.Field(String, graphql_name="subscriptionId")
    """Azure subscription id"""

    resource_group_name = sgqlc.types.Field(String, graphql_name="resourceGroupName")
    """Azure resource group name"""

    factory_name = sgqlc.types.Field(String, graphql_name="factoryName")
    """Azure Data Factory name"""


class AzureDevOpsBasicAuthCredentialsInput(sgqlc.types.Input):
    """Basic authentication credentials using Personal Access Token
    (PAT).
    """

    __schema__ = schema
    __field_names__ = ("access_token",)
    access_token = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accessToken")
    """Personal Access Token (PAT) for basic authentication"""


class AzureDevOpsOauthCredentialsInput(sgqlc.types.Input):
    """OAuth credentials for Azure DevOps integration (preferred method)."""

    __schema__ = schema
    __field_names__ = ("tenant_id", "client_id", "client_secret")
    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")
    """Azure AD tenant ID"""

    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")
    """OAuth client ID"""

    client_secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientSecret")
    """OAuth client secret"""


class AzureDevopsBasicAuthCredentialsInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("access_token",)
    access_token = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accessToken")
    """Typically an Azure DevOps personal access token"""


class AzureDevopsOauthCredentialsInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("tenant_id", "client_id", "client_secret")
    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")

    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")

    client_secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientSecret")


class AzureDevopsSourceSelectionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("project_id", "repository_id")
    project_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="projectId")
    """ID of Azure DevOps project"""

    repository_id = sgqlc.types.Field(String, graphql_name="repositoryId")
    """ID of Azure DevOps repository"""


class BiWarehouseSourcesInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("warehouse_resource_id", "warehouse_resource_type", "bi_warehouse_id")
    warehouse_resource_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="warehouseResourceId"
    )
    """Warehouse resource ID. This is a Monte Carlo ID"""

    warehouse_resource_type = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="warehouseResourceType"
    )
    """Warehouse type. Examples: snowflake, redshift, etc."""

    bi_warehouse_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="biWarehouseId")
    """The warehouse ID in the BI instance of the customer. This is an ID
    in the customer ID space and is not a Monte Carlo ID.
    """


class BigQueryUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("service_json",)
    service_json = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="serviceJson")
    """Service account key file as a base64 string"""


class BqConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("service_json",)
    service_json = sgqlc.types.Field(String, graphql_name="serviceJson")
    """Service account key file as a base64 string"""


class BulkUpdateAlertsValues(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("owner", "feedback")
    owner = sgqlc.types.Field(String, graphql_name="owner")

    feedback = sgqlc.types.Field(String, graphql_name="feedback")


class BulkUpdateIncidentsValues(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("owner", "feedback")
    owner = sgqlc.types.Field(String, graphql_name="owner")

    feedback = sgqlc.types.Field(String, graphql_name="feedback")


class CatalogMappingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("from_name", "to_name")
    from_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fromName")
    """From catalog object name."""

    to_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="toName")
    """To catalog object name."""


class ClassificationCategoriesInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("label", "description", "examples")
    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")

    description = sgqlc.types.Field(String, graphql_name="description")

    examples = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="examples"
    )


class CollectionBlockInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("resource_id", "project", "dataset")
    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """The resource UUID this collection block applies to."""

    project = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="project")
    """Top-level object hierarchy e.g. database, catalog, etc."""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Intermediate object hierarchy e.g. schema, database, etc."""


class CollectionBlockListParentScopeInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("resource_id", "project", "dataset")
    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Warehouse to scope the rules to"""

    project = sgqlc.types.Field(String, graphql_name="project")
    """Project/database to scope the rules to"""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Dataset/schema to scope the rules to"""


class ComparisonAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "metric",
        "custom_metric",
        "source_field",
        "target_field",
        "type",
        "operator",
        "threshold_value",
        "is_threshold_relative",
    )
    metric = sgqlc.types.Field(String, graphql_name="metric")

    custom_metric = sgqlc.types.Field("CustomComparisonMetricInput", graphql_name="customMetric")

    source_field = sgqlc.types.Field(String, graphql_name="sourceField")

    target_field = sgqlc.types.Field(String, graphql_name="targetField")

    type = sgqlc.types.Field(String, graphql_name="type")

    operator = sgqlc.types.Field(String, graphql_name="operator")

    threshold_value = sgqlc.types.Field(Float, graphql_name="thresholdValue")

    is_threshold_relative = sgqlc.types.Field(Boolean, graphql_name="isThresholdRelative")


class ConfluentKafkaConnectCredentialsInput(sgqlc.types.Input):
    """Credentials to Confluent Connect APIs"""

    __schema__ = schema
    __field_names__ = ("confluent_env", "cluster", "api_key", "secret", "url")
    confluent_env = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="confluentEnv")
    """Confluent environment."""

    cluster = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cluster")
    """Confluent Kafka cluster in which the connectors are defined."""

    api_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="apiKey")
    """Confluent Cloud API key."""

    secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="secret")
    """Confluent Cloud Api key's secret."""

    url = sgqlc.types.Field(String, graphql_name="url")
    """URL for the Confluent Connect."""


class ConfluentKafkaCredentialsInput(sgqlc.types.Input):
    """Credentials to a Confluent Kafka Cluster"""

    __schema__ = schema
    __field_names__ = ("cluster", "api_key", "secret", "url")
    cluster = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cluster")
    """Confluent Kafka cluster."""

    api_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="apiKey")
    """Confluent Kafka API key."""

    secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="secret")
    """Confluent Kafka Api key's secret."""

    url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="url")
    """URL for the Confluent kafka cluster."""


class ConnectionTestOptions(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dc_id", "skip_validation", "skip_permission_tests", "test_options")
    dc_id = sgqlc.types.Field(UUID, graphql_name="dcId")
    """DC UUID. To disambiguate accounts with multiple collectors."""

    skip_validation = sgqlc.types.Field(Boolean, graphql_name="skipValidation")
    """Skip all connection tests."""

    skip_permission_tests = sgqlc.types.Field(Boolean, graphql_name="skipPermissionTests")
    """Skips all permission tests for the service account/role for
    anysupported integrations. Only validates network connection
    between the DC and resource can be established.
    """

    test_options = sgqlc.types.Field("ValidatorTestOptions", graphql_name="testOptions")
    """Specify tests to run (Redshift only)."""


class CreateOrUpdateAgentTraceTableInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("uuid", "mcon", "connection_uuid", "span_format")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of existing agent trace table to update"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of the table"""

    connection_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="connectionUuid")
    """Connection UUID to query the table"""

    span_format = sgqlc.types.Field(AgentTraceFormatEnum, graphql_name="spanFormat")
    """Format of spans in the table"""


class CreatedByFilters(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("created_by", "is_template_managed", "namespace", "rule_name")
    created_by = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="createdBy")
    """Emails of users who created monitors to filter by"""

    is_template_managed = sgqlc.types.Field(Boolean, graphql_name="isTemplateManaged")
    """Filter only by monitors created with monitor-as-code (if true)"""

    namespace = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="namespace")
    """Filter by namespace name (for monitors created via monitor-as-
    code)
    """

    rule_name = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="ruleName")
    """Filter by rule names (for monitors created via monitor-as-code)"""


class CriteriaInput(sgqlc.types.Input):
    """Filtering criteria, specified by data type"""

    __schema__ = schema
    __field_names__ = (
        "string_filters",
        "timestamp_filters",
        "numeric_filters",
        "custom_where_clause",
    )
    string_filters = sgqlc.types.Field(
        sgqlc.types.list_of("StringFilterInput"), graphql_name="stringFilters"
    )
    """String filters"""

    timestamp_filters = sgqlc.types.Field(
        sgqlc.types.list_of("TimestampFilterInput"), graphql_name="timestampFilters"
    )
    """Timestamp filters"""

    numeric_filters = sgqlc.types.Field(
        sgqlc.types.list_of("NumericFilterInput"), graphql_name="numericFilters"
    )
    """Numeric filters"""

    custom_where_clause = sgqlc.types.Field(String, graphql_name="customWhereClause")
    """Custom where clause"""


class CustomComparisonMetricInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("uuid", "display_name", "source_sql_expression", "target_sql_expression")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    source_sql_expression = sgqlc.types.Field(String, graphql_name="sourceSqlExpression")

    target_sql_expression = sgqlc.types.Field(String, graphql_name="targetSqlExpression")


class CustomMetricInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("uuid", "display_name", "sql_expression")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    sql_expression = sgqlc.types.Field(String, graphql_name="sqlExpression")


class CustomMetricQueryInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "connection_id",
        "data_source",
        "mcon",
        "sql_expression",
        "time_axis_name",
        "time_axis_type",
        "agg_time_interval",
        "where_condition",
        "use_literal_period",
        "collection_lag_hours",
    )
    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """Connection UUID to use for the query"""

    data_source = sgqlc.types.Field("DataSourceUnionInput", graphql_name="dataSource")
    """Target data source"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Mcon of the target table"""

    sql_expression = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlExpression")
    """SQL expression of the custom metric"""

    time_axis_name = sgqlc.types.Field(String, graphql_name="timeAxisName")
    """Time axis name"""

    time_axis_type = sgqlc.types.Field(String, graphql_name="timeAxisType")
    """Time axis type"""

    agg_time_interval = sgqlc.types.Field(MonitorAggTimeInterval, graphql_name="aggTimeInterval")
    """Aggregation time interval to use. (defaults to HOUR)"""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """WHERE condition to apply to the query"""

    use_literal_period = sgqlc.types.Field(Boolean, graphql_name="useLiteralPeriod")
    """Use a literal period in the queries"""

    collection_lag_hours = sgqlc.types.Field(Int, graphql_name="collectionLagHours")
    """Time to offset the collection time bucket by in hours. Only when
    using literal periods
    """


class CustomRuleComparisonInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "comparison_type",
        "full_table_id",
        "full_table_ids",
        "mcon",
        "field",
        "fields",
        "metric",
        "custom_metric",
        "operator",
        "threshold",
        "upper_threshold",
        "lower_threshold",
        "baseline_agg_function",
        "baseline_interval_minutes",
        "is_threshold_relative",
        "threshold_lookback_minutes",
        "threshold_ref",
        "threshold_sensitivity",
        "min_buffer",
        "max_buffer",
        "number_of_agg_periods",
        "threshold_lookback_data_points",
    )
    comparison_type = sgqlc.types.Field(ComparisonType, graphql_name="comparisonType")

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    full_table_ids = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fullTableIds")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    field = sgqlc.types.Field(String, graphql_name="field")

    fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fields"
    )

    metric = sgqlc.types.Field(String, graphql_name="metric")

    custom_metric = sgqlc.types.Field(CustomMetricInput, graphql_name="customMetric")

    operator = sgqlc.types.Field(CustomRuleComparisonOperator, graphql_name="operator")
    """Comparison operator"""

    threshold = sgqlc.types.Field(Float, graphql_name="threshold")
    """Threshold value"""

    upper_threshold = sgqlc.types.Field(Float, graphql_name="upperThreshold")
    """Upper threshold value"""

    lower_threshold = sgqlc.types.Field(Float, graphql_name="lowerThreshold")
    """Lower threshold value"""

    baseline_agg_function = sgqlc.types.Field(
        AggregationFunction, graphql_name="baselineAggFunction"
    )
    """Function used to aggregate historical data points to calculate
    baseline
    """

    baseline_interval_minutes = sgqlc.types.Field(Int, graphql_name="baselineIntervalMinutes")
    """Time interval to aggregate over to calculate baseline."""

    is_threshold_relative = sgqlc.types.Field(Boolean, graphql_name="isThresholdRelative")
    """True, if threshold is a relative percentage change of baseline.
    False, if threshold is absolute change
    """

    threshold_lookback_minutes = sgqlc.types.Field(Int, graphql_name="thresholdLookbackMinutes")
    """Time to look back for rules which compare current and past values."""

    threshold_ref = sgqlc.types.Field(String, graphql_name="thresholdRef")
    """Key used to retrieve the threshold values from external source"""

    threshold_sensitivity = sgqlc.types.Field(
        SensitivityLevels, graphql_name="thresholdSensitivity"
    )
    """Sensitivity for automated thresholds"""

    min_buffer = sgqlc.types.Field("ThresholdModifierInput", graphql_name="minBuffer")
    """The lower bound buffer to modify the alert threshold."""

    max_buffer = sgqlc.types.Field("ThresholdModifierInput", graphql_name="maxBuffer")
    """The upper bound buffer to modify the alert threshold."""

    number_of_agg_periods = sgqlc.types.Field(Int, graphql_name="numberOfAggPeriods")
    """The number of periods to use in the aggregate comparison for
    Volume Growth comparisons.
    """

    threshold_lookback_data_points = sgqlc.types.Field(
        Int, graphql_name="thresholdLookbackDataPoints"
    )
    """Number of data points to look back for rules which compare current
    and past values.
    """


class CustomRuleSnoozeInput(sgqlc.types.Input):
    """input variables for snoozing"""

    __schema__ = schema
    __field_names__ = ("rule_uuid", "snooze_minutes", "conditional_snooze")
    rule_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="ruleUuid")
    """UUID of rule to snooze"""

    snooze_minutes = sgqlc.types.Field(Int, graphql_name="snoozeMinutes")
    """number of minutes to snooze rule"""

    conditional_snooze = sgqlc.types.Field(Boolean, graphql_name="conditionalSnooze")
    """snooze rule until breach condition changes or is resolved"""


class CustomRuleSqlBlocksInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("alert_condition", "where_condition", "group_by")
    alert_condition = sgqlc.types.Field("FilterGroupInput", graphql_name="alertCondition")

    where_condition = sgqlc.types.Field("FilterGroupInput", graphql_name="whereCondition")

    group_by = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterValueUnionInput")), graphql_name="groupBy"
    )


class CustomSqlRuleAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "type",
        "operator",
        "threshold",
        "baseline_agg_function",
        "baseline_interval_minutes",
        "is_threshold_relative",
        "threshold_sensitivity",
        "upper_threshold",
        "lower_threshold",
    )
    type = sgqlc.types.Field(sgqlc.types.non_null(ComparisonType), graphql_name="type")

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleComparisonOperator), graphql_name="operator"
    )
    """Comparison operator"""

    threshold = sgqlc.types.Field(Float, graphql_name="threshold")
    """Threshold value"""

    baseline_agg_function = sgqlc.types.Field(
        AggregationFunction, graphql_name="baselineAggFunction"
    )
    """Function used to aggregate historical data points to calculate
    baseline
    """

    baseline_interval_minutes = sgqlc.types.Field(Int, graphql_name="baselineIntervalMinutes")
    """Time interval to aggregate over to calculate baseline."""

    is_threshold_relative = sgqlc.types.Field(Boolean, graphql_name="isThresholdRelative")
    """True, if threshold is a relative percentage change of baseline.
    False, if threshold is absolute change
    """

    threshold_sensitivity = sgqlc.types.Field(
        SensitivityLevels, graphql_name="thresholdSensitivity"
    )
    """Sensitivity for automated thresholds"""

    upper_threshold = sgqlc.types.Field(Float, graphql_name="upperThreshold")
    """Upper threshold value"""

    lower_threshold = sgqlc.types.Field(Float, graphql_name="lowerThreshold")
    """Lower threshold value"""


class DODCriteriaInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "time_range",
        "data_product_uuids",
        "audience_uuids",
        "domain_uuids",
        "tags",
        "monitor_tags",
    )
    time_range = sgqlc.types.Field("TimeRangeInput", graphql_name="timeRange")
    """Time range criteria."""

    data_product_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(UUID), graphql_name="dataProductUuids"
    )
    """Data product uuid filters."""

    audience_uuids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="audienceUuids")
    """Audience uuid filters."""

    domain_uuids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="domainUuids")
    """Domain uuid filters."""

    tags = sgqlc.types.Field(sgqlc.types.list_of("TagKeyValuePairInput"), graphql_name="tags")
    """Tags filters."""

    monitor_tags = sgqlc.types.Field(
        sgqlc.types.list_of("TagKeyValuePairInput"), graphql_name="monitorTags"
    )
    """Monitor tags filters."""


class DataExplorerComparisonDashboardInputType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "warehouse_uuid",
        "name",
        "dashboard_left",
        "dashboard_right",
        "widgets",
        "criteria",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of comparison dashboard, required if updating existing object"""

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")
    """UUID of warehouse"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Descriptive name"""

    dashboard_left = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dashboardLeft")
    """First dashboard to be compared"""

    dashboard_right = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dashboardRight")
    """Second dashboard to be compared"""

    widgets = sgqlc.types.Field(
        sgqlc.types.list_of("DataExplorerWidgetInputType"), graphql_name="widgets"
    )

    criteria = sgqlc.types.Field(JSONString, graphql_name="criteria")
    """Saved criteria"""


class DataExplorerDashboardInputType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "warehouse_uuid",
        "mcon",
        "name",
        "time_axis_field_name",
        "base_where_clause",
        "widgets",
        "criteria",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of dashboard, required if updating existing object"""

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")
    """UUID of warehouse"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of underlying warehouse table"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Descriptive name of dashboard"""

    time_axis_field_name = sgqlc.types.Field(String, graphql_name="timeAxisFieldName")
    """Time axis field name"""

    base_where_clause = sgqlc.types.Field(String, graphql_name="baseWhereClause")
    """Base where clause"""

    widgets = sgqlc.types.Field(
        sgqlc.types.list_of("DataExplorerWidgetInputType"), graphql_name="widgets"
    )
    """Configured widgets"""

    criteria = sgqlc.types.Field(JSONString, graphql_name="criteria")
    """Saved criteria"""


class DataExplorerWidgetInputType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "widget_type", "config")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")
    """Field name visualized by this widget"""

    widget_type = sgqlc.types.Field(sgqlc.types.non_null(WidgetType), graphql_name="widgetType")
    """Type of widget"""

    config = sgqlc.types.Field(JSONString, graphql_name="config")
    """Additional configuration for widget"""


class DataProfilerWidgetDataInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "dataset",
        "widget_type",
        "field_name",
        "field_name_pattern",
        "limit",
        "offset",
        "widget_config",
    )
    dataset = sgqlc.types.Field(sgqlc.types.non_null("DatasetInput"), graphql_name="dataset")

    widget_type = sgqlc.types.Field(sgqlc.types.non_null(WidgetType), graphql_name="widgetType")

    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """filter by field name. Supported by DISCRETE and FIELD_PROFILE
    widgets
    """

    field_name_pattern = sgqlc.types.Field(String, graphql_name="fieldNamePattern")
    """filter by field name pattern. Supported by FIELD_PROFILE widgets"""

    limit = sgqlc.types.Field(Int, graphql_name="limit")

    offset = sgqlc.types.Field(Int, graphql_name="offset")

    widget_config = sgqlc.types.Field("WidgetConfig", graphql_name="widgetConfig")
    """Widget configuration"""


class DataShareInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("type", "account", "region", "organization")
    type = sgqlc.types.Field(DataShareType, graphql_name="type")
    """Type of data share (default: 'snowflake')"""

    account = sgqlc.types.Field(String, graphql_name="account")
    """Data share account identifier (optional if account has only one)"""

    region = sgqlc.types.Field(String, graphql_name="region")
    """Data share region (optional if account has only one)"""

    organization = sgqlc.types.Field(String, graphql_name="organization")
    """Organization identifier"""


class DataSourceSchemaInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("fields",)
    fields = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SchemaFieldInput"))),
        graphql_name="fields",
    )


class DataSourceUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("sql", "mcon", "transforms", "type", "connection_type", "schema")
    sql = sgqlc.types.Field(String, graphql_name="sql")
    """The SQL query that defines the source of the data"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    transforms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("TransformInput")), graphql_name="transforms"
    )

    type = sgqlc.types.Field(sgqlc.types.non_null(DataSourceType), graphql_name="type")

    connection_type = sgqlc.types.Field(String, graphql_name="connectionType")

    schema = sgqlc.types.Field(DataSourceSchemaInput, graphql_name="schema")


class DatabricksSqlWarehouseConnectionInput(sgqlc.types.Input):
    """Credentials and connection details to a Databricks SQL warehouse
    connection
    """

    __schema__ = schema
    __field_names__ = ("dc_id", "databricks_config")
    dc_id = sgqlc.types.Field(UUID, graphql_name="dcId")
    """The Data Collector UUID for a new Databricks Connection"""

    databricks_config = sgqlc.types.Field(
        "DatabricksSqlWarehouseInput", graphql_name="databricksConfig"
    )
    """Configuration for Databricks."""


class DatabricksSqlWarehouseInput(sgqlc.types.Input):
    """Credentials to a Databricks sql warehouse."""

    __schema__ = schema
    __field_names__ = (
        "databricks_workspace_url",
        "databricks_warehouse_id",
        "databricks_token",
        "databricks_client_id",
        "databricks_client_secret",
        "databricks_workspace_id",
        "azure_tenant_id",
        "azure_workspace_resource_id",
    )
    databricks_workspace_url = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="databricksWorkspaceUrl"
    )
    """Databricks workspace URL"""

    databricks_warehouse_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="databricksWarehouseId"
    )
    """Databricks warehouse ID"""

    databricks_token = sgqlc.types.Field(String, graphql_name="databricksToken")
    """User token"""

    databricks_client_id = sgqlc.types.Field(String, graphql_name="databricksClientId")
    """Client ID (for M2M oauth)"""

    databricks_client_secret = sgqlc.types.Field(String, graphql_name="databricksClientSecret")
    """Client Secret (for M2M oauth)"""

    databricks_workspace_id = sgqlc.types.Field(String, graphql_name="databricksWorkspaceId")
    """Databricks workspace ID"""

    azure_tenant_id = sgqlc.types.Field(String, graphql_name="azureTenantId")
    """Azure Tenant ID (for M2M oauth with an Entra ID managed service
    principal)
    """

    azure_workspace_resource_id = sgqlc.types.Field(String, graphql_name="azureWorkspaceResourceId")
    """Azure ARM resource ID of the Databricks workspace (for M2M oauth
    with an Entra ID managed service principal)
    """


class DatabricksSqlWarehouseUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "databricks_workspace_url",
        "databricks_warehouse_id",
        "databricks_token",
        "databricks_client_id",
        "databricks_client_secret",
        "databricks_workspace_id",
    )
    databricks_workspace_url = sgqlc.types.Field(String, graphql_name="databricksWorkspaceUrl")
    """Databricks workspace URL"""

    databricks_warehouse_id = sgqlc.types.Field(String, graphql_name="databricksWarehouseId")
    """Databricks warehouse ID"""

    databricks_token = sgqlc.types.Field(String, graphql_name="databricksToken")
    """User token"""

    databricks_client_id = sgqlc.types.Field(String, graphql_name="databricksClientId")
    """Client ID (for M2M oauth)"""

    databricks_client_secret = sgqlc.types.Field(String, graphql_name="databricksClientSecret")
    """Client Secret (for M2M oauth)"""

    databricks_workspace_id = sgqlc.types.Field(String, graphql_name="databricksWorkspaceId")
    """Databricks workspace ID"""


class DatasetFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dataset_mcons",)
    dataset_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="datasetMcons")
    """MCONs of datasets to filter by."""


class DatasetInput(sgqlc.types.Input):
    """Specifies base table + criteria for dashboard/widget"""

    __schema__ = schema
    __field_names__ = ("mcon", "criteria", "base_where_clause", "connection_id")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of underlying table"""

    criteria = sgqlc.types.Field(CriteriaInput, graphql_name="criteria")
    """Filtering criteria"""

    base_where_clause = sgqlc.types.Field(String, graphql_name="baseWhereClause")
    """Base where clause"""

    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """Optional connection ID to use for queries"""


class DateTimeRangeInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("before", "after")
    before = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="before")
    """Return records before this time."""

    after = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="after")
    """Return records after or at this time."""


class DbtArtifactsInput(sgqlc.types.Input):
    """dbt artifacts"""

    __schema__ = schema
    __field_names__ = ("manifest", "run_results", "logs")
    manifest = sgqlc.types.Field(String, graphql_name="manifest")
    """manifest file name"""

    run_results = sgqlc.types.Field(String, graphql_name="runResults")
    """run results file name"""

    logs = sgqlc.types.Field(String, graphql_name="logs")
    """logs file name"""


class DbtCloudConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "dbt_cloud_api_token",
        "dbt_cloud_account_id",
        "dbt_cloud_base_url",
        "dbt_cloud_webhook_hmac_secret",
        "dbt_cloud_webhook_id",
    )
    dbt_cloud_api_token = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="dbtCloudApiToken"
    )
    """dbt Cloud API token"""

    dbt_cloud_account_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="dbtCloudAccountId"
    )
    """dbt Cloud account ID"""

    dbt_cloud_base_url = sgqlc.types.Field(String, graphql_name="dbtCloudBaseUrl")
    """dbt Cloud base URL"""

    dbt_cloud_webhook_hmac_secret = sgqlc.types.Field(
        String, graphql_name="dbtCloudWebhookHmacSecret"
    )
    """dbt Cloud webhook HMAC secret"""

    dbt_cloud_webhook_id = sgqlc.types.Field(String, graphql_name="dbtCloudWebhookId")
    """dbt Cloud webhook ID"""


class DbtCloudUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "dbt_cloud_base_url",
        "dbt_cloud_webhook_hmac_secret",
        "dbt_cloud_webhook_id",
        "dbt_cloud_api_token",
        "dbt_cloud_account_id",
    )
    dbt_cloud_base_url = sgqlc.types.Field(String, graphql_name="dbtCloudBaseUrl")
    """dbt cloud URL"""

    dbt_cloud_webhook_hmac_secret = sgqlc.types.Field(
        String, graphql_name="dbtCloudWebhookHmacSecret"
    )
    """dbt cloud webhook HMAC secret"""

    dbt_cloud_webhook_id = sgqlc.types.Field(String, graphql_name="dbtCloudWebhookId")
    """dbt cloud webhook ID"""

    dbt_cloud_api_token = sgqlc.types.Field(String, graphql_name="dbtCloudApiToken")
    """dbt cloud API token"""

    dbt_cloud_account_id = sgqlc.types.Field(String, graphql_name="dbtCloudAccountId")
    """dbt cloud account ID"""


class DeleteAgentTraceTableInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the agent trace table to delete"""


class ExtendedDataSourceInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "data_source",
        "dw_id",
        "where_condition",
        "segments",
        "connection_uuid",
        "timeout",
    )
    data_source = sgqlc.types.Field(
        sgqlc.types.non_null(DataSourceUnionInput), graphql_name="dataSource"
    )
    """Data source can be table or sql."""

    dw_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dwId")
    """Warehouse of the data source."""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """Where condition used for table data source."""

    segments = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterValueUnionInput")), graphql_name="segments"
    )
    """segments for data source."""

    connection_uuid = sgqlc.types.Field(UUID, graphql_name="connectionUuid")
    """Connection UUID for the data source."""

    timeout = sgqlc.types.Field(Int, graphql_name="timeout")
    """Timeout for the SQL query."""


class FieldConfigInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("type", "count", "field")
    type = sgqlc.types.Field(sgqlc.types.non_null(FieldConfigType), graphql_name="type")

    count = sgqlc.types.Field(Int, graphql_name="count")

    field = sgqlc.types.Field(String, graphql_name="field")


class FieldMetricFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "operator", "value")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field to filter by"""

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleComparisonOperator), graphql_name="operator"
    )
    """Operator to filter field by"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Value to filter field by"""


class FieldMetricInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "table_mcon",
        "table_mcons",
        "field_name",
        "field_names",
        "metric_type",
        "value_list",
        "value_sql",
        "filters",
    )
    table_mcon = sgqlc.types.Field(String, graphql_name="tableMcon")
    """MCON of the table the metric is based on"""

    table_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tableMcons")
    """MCONs of the table the metric is based on"""

    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Name of the field the metric is based on"""

    field_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fieldNames")
    """Name of the fields the metric is based on"""

    metric_type = sgqlc.types.Field(
        sgqlc.types.non_null(FieldMetricType), graphql_name="metricType"
    )
    """Type of metric to compute"""

    value_list = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="valueList")
    """Values for metrics that check for cardinality"""

    value_sql = sgqlc.types.Field(String, graphql_name="valueSql")
    """Values SQL expression for metrics that check for cardinality"""

    filters = sgqlc.types.Field(sgqlc.types.list_of(FieldMetricFilterInput), graphql_name="filters")
    """Filters for which rows the metric is computed over"""


class FieldQueryFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "operator", "value")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field to filter by"""

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleComparisonOperator), graphql_name="operator"
    )
    """Operator to filter field by"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Value to filter field by"""


class FieldQueryParametersInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "table_mcons",
        "field_names",
        "query_type",
        "value_list",
        "value_sql",
        "filters",
    )
    table_mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="tableMcons"
    )
    """MCONs of the table the query is based on"""

    field_names = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="fieldNames"
    )
    """Name of the fields the query is based on"""

    query_type = sgqlc.types.Field(sgqlc.types.non_null(FieldQueryType), graphql_name="queryType")
    """Type of query"""

    value_list = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="valueList")
    """Values for queries that check for cardinality"""

    value_sql = sgqlc.types.Field(String, graphql_name="valueSql")
    """Values SQL expression for metrics that check for cardinality"""

    filters = sgqlc.types.Field(sgqlc.types.list_of(FieldQueryFilterInput), graphql_name="filters")
    """Filters for which rows the query is computed over"""


class FilterGroupInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("type", "id", "conditions", "operator")
    type = sgqlc.types.Field(FilterType, graphql_name="type")

    id = sgqlc.types.Field(String, graphql_name="id")

    conditions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterUnionInput")), graphql_name="conditions"
    )

    operator = sgqlc.types.Field(BooleanOperator, graphql_name="operator")


class FilterPredicateInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "negated")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    negated = sgqlc.types.Field(Boolean, graphql_name="negated")


class FilterUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "value",
        "predicate",
        "left",
        "right",
        "sql",
        "conditions",
        "operator",
        "type",
        "id",
    )
    value = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterValueUnionInput")), graphql_name="value"
    )

    predicate = sgqlc.types.Field(FilterPredicateInput, graphql_name="predicate")

    left = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterValueUnionInput")), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterValueUnionInput")), graphql_name="right"
    )

    sql = sgqlc.types.Field(String, graphql_name="sql")

    conditions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("FilterUnionInput")), graphql_name="conditions"
    )

    operator = sgqlc.types.Field(BooleanOperator, graphql_name="operator")

    type = sgqlc.types.Field(sgqlc.types.non_null(FilterType), graphql_name="type")

    id = sgqlc.types.Field(String, graphql_name="id")


class FilterValueUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("literal", "sql", "field", "table", "mcon", "type", "id")
    literal = sgqlc.types.Field(String, graphql_name="literal")

    sql = sgqlc.types.Field(String, graphql_name="sql")

    field = sgqlc.types.Field(String, graphql_name="field")

    table = sgqlc.types.Field(String, graphql_name="table")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    type = sgqlc.types.Field(sgqlc.types.non_null(FilterValueType), graphql_name="type")

    id = sgqlc.types.Field(String, graphql_name="id")


class FreshnessAutomatedAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("sensitivity_level",)
    sensitivity_level = sgqlc.types.Field(
        sgqlc.types.non_null(SensitivityLevels), graphql_name="sensitivityLevel"
    )
    """Sensitivity for automated thresholds"""


class FreshnessExplicitAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "start_time",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "timezone",
        "is_auto_schedule_config",
        "threshold",
    )
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of the collection"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Collection interval in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Collection interval in crontab format"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions"""

    is_auto_schedule_config = sgqlc.types.Field(Boolean, graphql_name="isAutoScheduleConfig")
    """Set to true to use auto schedule configuration"""

    threshold = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="threshold")
    """Explicit freshness threshold in minutes"""


class GetExplanationForEventRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("event_uuid", "start_time", "end_time")
    event_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="eventUuid")
    """Event UUID"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time range. By default, current time - 4 weeks"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """End time range. By default, current time"""


class GetExplanationRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("query_group", "start_time", "end_time")
    query_group = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="queryGroup")
    """Query group hash"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time range. By default, current time - 4 weeks"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """End time range. By default, current time"""


class GetTracesInput(sgqlc.types.Input):
    """Input parameters for GetTraces query."""

    __schema__ = schema
    __field_names__ = (
        "agent_name",
        "trace_table_mcon",
        "start_time",
        "end_time",
        "filters",
        "first",
        "after",
        "last",
        "before",
        "sort_field",
        "sort_direction",
    )
    agent_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="agentName")
    """Agent name to filter by"""

    trace_table_mcon = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="traceTableMcon"
    )
    """MCON of the trace table to query. Filters traces to only those
    from this table.
    """

    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")
    """Start of time range (inclusive)"""

    end_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="endTime")
    """End of time range (inclusive)"""

    filters = sgqlc.types.Field("TraceFiltersInput", graphql_name="filters")
    """Optional filters to refine results"""

    first = sgqlc.types.Field(Int, graphql_name="first")
    """Number of records to fetch for forward pagination"""

    after = sgqlc.types.Field(String, graphql_name="after")
    """Cursor for forward pagination"""

    last = sgqlc.types.Field(Int, graphql_name="last")
    """Number of records to fetch for backward pagination"""

    before = sgqlc.types.Field(String, graphql_name="before")
    """Cursor for backward pagination"""

    sort_field = sgqlc.types.Field(TraceSortField, graphql_name="sortField")
    """Field to sort by"""

    sort_direction = sgqlc.types.Field(TraceSortDirection, graphql_name="sortDirection")
    """Sort direction"""


class GitlabNamespaceSelection(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("namespace_id", "select_all", "projects", "parents")
    namespace_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="namespaceId")
    """GitLab ID of the group or subgroup"""

    select_all = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="selectAll")
    """True if all projects in the namespace are selected"""

    projects = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="projects")
    """Optional: List of GitLab projects IDs or NULL (=all projects)"""

    parents = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="parents")
    """Optional: List of all parent namespace IDs"""


class ImportanceScoreTableStatsRule(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("operator", "value", "value_min", "value_max")
    operator = sgqlc.types.Field(
        sgqlc.types.non_null(ImportanceScoreOperator), graphql_name="operator"
    )
    """Comparison operator. Options include: ==, >=, <=, >, <, RANGE"""

    value = sgqlc.types.Field(Float, graphql_name="value")

    value_min = sgqlc.types.Field(Float, graphql_name="valueMin")

    value_max = sgqlc.types.Field(Float, graphql_name="valueMax")


class IncidentsFilterDataFilterType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "value")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")

    value = sgqlc.types.Field(sgqlc.types.non_null(GenericScalar), graphql_name="value")


class IncidentsFilterDataRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "search_criteria", "first", "after", "search_value")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")

    search_criteria = sgqlc.types.Field(
        sgqlc.types.non_null("IncidentsFilterDataSearchCriteriaType"), graphql_name="searchCriteria"
    )

    first = sgqlc.types.Field(Int, graphql_name="first")
    """Number of results to return"""

    after = sgqlc.types.Field(String, graphql_name="after")
    """Cursor to paginate results"""

    search_value = sgqlc.types.Field(String, graphql_name="searchValue")
    """Respond with filter values which contain this text"""


class IncidentsFilterDataSearchCriteriaType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("start_time", "end_time", "filters")
    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")
    """filter for incidents after or equal to this time"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """filter for incidents before this time"""

    filters = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentsFilterDataFilterType), graphql_name="filters"
    )
    """List of filters to apply to incidents"""


class IndexedFieldFilterType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "values", "operator")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field name"""

    values = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="values")
    """Values to filter by"""

    operator = sgqlc.types.Field(FieldValueFilterOperator, graphql_name="operator")
    """comparison operator to use when filtering"""


class InformaticaConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("username", "password")
    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")
    """Username"""

    password = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="password")
    """Password"""


class InputObjectProperty(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("mcon_id", "property_name", "property_value", "property_source_type")
    mcon_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mconId")
    """Monte Carlo full identifier for an entity"""

    property_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="propertyName")
    """Name of the property (AKA tag key)"""

    property_value = sgqlc.types.Field(String, graphql_name="propertyValue")
    """Value of the property (AKA tag value)"""

    property_source_type = sgqlc.types.Field(String, graphql_name="propertySourceType")
    """Where property originated."""


class InviteUsersInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("emails", "client_mutation_id")
    emails = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="emails"
    )

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class IsImportantTableStatsRule(sgqlc.types.Input):
    """The key asset rule matches the is_important table stat"""

    __schema__ = schema
    __field_names__ = ("value",)
    value = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="value")


class JiraStatusMappingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("incident_feedback", "jira_status")
    incident_feedback = sgqlc.types.Field(String, graphql_name="incidentFeedback")
    """The feedback that will be set on the Monte Carlo incident if the
    Jira ticket is set to any of the provided Jira statuses
    """

    jira_status = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="jiraStatus"
    )
    """The Jira statuses that will map to the Monte Carlo incident
    feedback
    """


class JiraWebhookConfigInput(sgqlc.types.Input):
    """Jira webhook config"""

    __schema__ = schema
    __field_names__ = ("status_mappings",)
    status_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraStatusMappingInput)),
        graphql_name="statusMappings",
    )
    """Status mapping"""


class JobsPerformanceFacetFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("facet", "include_options", "exclude_options")
    facet = sgqlc.types.Field(sgqlc.types.non_null(JobPerformanceFacet), graphql_name="facet")
    """Facet these filter selections apply to"""

    include_options = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="includeOptions"
    )
    """Filter to include only these options, if provided"""

    exclude_options = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="excludeOptions"
    )
    """Filter to exclude these options, if provided"""


class JobsPerformanceFacetQueryInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("facet", "search")
    facet = sgqlc.types.Field(sgqlc.types.non_null(JobPerformanceFacet), graphql_name="facet")
    """The specific facet to get options/counts for"""

    search = sgqlc.types.Field(String, graphql_name="search")
    """Optional search text to use to filter the returned facet options"""


class JobsPerformanceFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("start_time", "end_time", "facet_filters", "job_mcons")
    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")
    """Starting time of period to query for"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """Ending time of period to query for"""

    facet_filters = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JobsPerformanceFacetFilterInput)),
        graphql_name="facetFilters",
    )
    """All currently applied facet filters"""

    job_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="jobMcons"
    )
    """Job mcons to filter by"""


class JobsPerformancePagingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("first", "after", "last", "before", "order_by", "order_direction")
    first = sgqlc.types.Field(Int, graphql_name="first")
    """Number of items to retrieve after the cursor. Defaults to 20 if no
    other paging parameters are provided
    """

    after = sgqlc.types.Field(String, graphql_name="after")
    """Starting cursor when paging forward"""

    last = sgqlc.types.Field(Int, graphql_name="last")
    """Number of items to retrieve before the cursor when paging backward"""

    before = sgqlc.types.Field(String, graphql_name="before")
    """Ending cursor when paging backward"""

    order_by = sgqlc.types.Field(JobsPerformanceSummarySort, graphql_name="orderBy")
    """Field by which to order the results. Defaults to
    LAST_RUN_START_TIME
    """

    order_direction = sgqlc.types.Field(EtlPerformanceSortDirection, graphql_name="orderDirection")
    """Sort direction. Defaults to EnumMeta.ASC"""


class LineageEdgeInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("source_mcon", "destination_mcon")
    source_mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sourceMcon")
    """Source table MCON of an edge"""

    destination_mcon = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="destinationMcon"
    )
    """Destination table MCON of an edge"""


class LineageFilter(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "values", "operator")
    name = sgqlc.types.Field(sgqlc.types.non_null(LineageFilterName), graphql_name="name")
    """Name of the filter"""

    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="values"
    )
    """Filter values"""

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(LineageFilterOperator), graphql_name="operator"
    )
    """Filter operator"""


class LookerConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("base_url", "client_id", "client_secret", "verify_ssl")
    base_url = sgqlc.types.Field(String, graphql_name="baseUrl")
    """Host url"""

    client_id = sgqlc.types.Field(String, graphql_name="clientId")
    """Looker client id"""

    client_secret = sgqlc.types.Field(String, graphql_name="clientSecret")
    """Looker client secret"""

    verify_ssl = sgqlc.types.Field(Boolean, graphql_name="verifySsl")
    """Verify SSL (uncheck for self-signed certs)"""


class LookerGitAuthConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("repo_url", "username", "token", "ssh_key")
    repo_url = sgqlc.types.Field(String, graphql_name="repoUrl")
    """For HTTPS the repository URL as https://server/project.gitFor SSH
    the repository URL as ssh://[user@]server/project.gitor the
    shorter form [user@]server:project.git
    """

    username = sgqlc.types.Field(String, graphql_name="username")
    """The git username"""

    token = sgqlc.types.Field(String, graphql_name="token")
    """The access token for git HTTPS integrations"""

    ssh_key = sgqlc.types.Field(String, graphql_name="sshKey")
    """SSH key, base64-encoded"""


class LookerGitAuthUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("ssh_key", "repo_url", "username", "token")
    ssh_key = sgqlc.types.Field(String, graphql_name="sshKey")
    """SSH key, base64-encoded"""

    repo_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="repoUrl")
    """Repository URL as ssh://[user@]server/project.git or the shorter
    form [user@]server:project.git
    """

    username = sgqlc.types.Field(String, graphql_name="username")
    """Username for Git authentication"""

    token = sgqlc.types.Field(String, graphql_name="token")
    """Token for Git authentication"""


class LookerGitCloneConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("repo_url", "username", "token")
    repo_url = sgqlc.types.Field(String, graphql_name="repoUrl")
    """Repository URL as https://server/project.git"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """The git username"""

    token = sgqlc.types.Field(String, graphql_name="token")
    """The access token for git HTTPS integrations"""


class LookerUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("base_url", "client_id", "client_secret", "verify_ssl")
    base_url = sgqlc.types.Field(String, graphql_name="baseUrl")
    """Host url"""

    client_id = sgqlc.types.Field(String, graphql_name="clientId")
    """Looker client id"""

    client_secret = sgqlc.types.Field(String, graphql_name="clientSecret")
    """Looker client secret"""

    verify_ssl = sgqlc.types.Field(Boolean, graphql_name="verifySsl")
    """Verify SSL (uncheck for self-signed certs)"""


class MergeAlertsInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("id", "severity", "status", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="id")
    """UUID of the alert to update"""

    severity = sgqlc.types.Field(SeverityInput, graphql_name="severity")
    """By assigning a severity to the alert, the alert will be declared
    an incident
    """

    status = sgqlc.types.Field(AlertStatusInput, graphql_name="status")
    """Status to assign to the alert."""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Custom name for the alert."""


class MetricAggregationInputType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("metric", "aggregation")
    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")
    """Query performance metric"""

    aggregation = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="aggregation")
    """Metric aggregation function"""


class MetricAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "metric",
        "custom_metric",
        "fields",
        "type",
        "operator",
        "threshold_value",
        "lower_threshold",
        "upper_threshold",
        "id",
    )
    metric = sgqlc.types.Field(String, graphql_name="metric")

    custom_metric = sgqlc.types.Field(CustomMetricInput, graphql_name="customMetric")

    fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fields"
    )

    type = sgqlc.types.Field(String, graphql_name="type")

    operator = sgqlc.types.Field(String, graphql_name="operator")

    threshold_value = sgqlc.types.Field(Float, graphql_name="thresholdValue")

    lower_threshold = sgqlc.types.Field(Float, graphql_name="lowerThreshold")

    upper_threshold = sgqlc.types.Field(Float, graphql_name="upperThreshold")

    id = sgqlc.types.Field(String, graphql_name="id")


class MetricsFilter(sgqlc.types.Input):
    """Filters for the metrics to be fetched"""

    __schema__ = schema
    __field_names__ = (
        "monitor_id",
        "mcon",
        "full_table_id",
        "dw_id",
        "segments_filter",
        "where_condition",
        "label",
        "field",
        "ootb",
        "data_source_uuid",
    )
    monitor_id = sgqlc.types.Field(UUID, graphql_name="monitorId")
    """UUID of the monitor or custom rule"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON of the asset tracked by the metrics to be fetched"""

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")
    """Full table ID of the table tracked by the metrics to be fetched"""

    dw_id = sgqlc.types.Field(UUID, graphql_name="dwId")
    """Warehouse UUID of the asset tracked by the metrics to be fetched"""

    segments_filter = sgqlc.types.Field(
        sgqlc.types.list_of("SegmentsFilter"), graphql_name="segmentsFilter"
    )
    """DEPRECATED: use whereCondition or label instead. Call will fail."""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """Filter to the segment with this value as the whereCondition."""

    label = sgqlc.types.Field(String, graphql_name="label")
    """Filter to the segment with this value as the label."""

    field = sgqlc.types.Field(String, graphql_name="field")
    """Field name for filtering based on fields for field health monitors"""

    ootb = sgqlc.types.Field(Boolean, graphql_name="ootb")
    """Indicates whether to get the datapoints for out-of-the-box metric.
    If this is true, then the monitor_id parameter will be ignored.
    """

    data_source_uuid = sgqlc.types.Field(UUID, graphql_name="dataSourceUuid")
    """UUID of the data source associated with the metric. Used to
    differentiate source vs. target metric.
    """


class ModifyCollectionBlockListInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "id",
        "resource_id",
        "project",
        "dataset",
        "table_name",
        "match_type",
        "effect",
    )
    id = sgqlc.types.Field(String, graphql_name="id")
    """ID of the rule. If provided, the rule will be updated instead of
    created.
    """

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Warehouse that the collection preference belongs to."""

    project = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="project")
    """Value used to match against project/database."""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Value used to match against dataset/schema."""

    table_name = sgqlc.types.Field(String, graphql_name="tableName")
    """Value used to match against table name."""

    match_type = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionPreferenceMatchType), graphql_name="matchType"
    )

    effect = sgqlc.types.Field(CollectionPreferenceEffectType, graphql_name="effect")


class MonitorConfigurationInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("mcon", "time_fields")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MC mcon"""

    time_fields = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TimestampResult")), graphql_name="timeFields"
    )
    """field and timestamp for monitor configuration"""


class MonitorRecommendationsInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dataset", "field_names", "recommendation_type", "models")
    dataset = sgqlc.types.Field(sgqlc.types.non_null(DatasetInput), graphql_name="dataset")

    field_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fieldNames")
    """Recommend monitors for specific field names"""

    recommendation_type = sgqlc.types.Field(
        MonitorRecommendationType, graphql_name="recommendationType"
    )
    """Generate this type of monitor recommendations"""

    models = sgqlc.types.Field(
        sgqlc.types.list_of(MonitorRecommendationModel), graphql_name="models"
    )
    """Recommend monitors for specific models. Default for HEURISTIC is
    VALIDATION, METRIC and for AI_VALIDATION is VALIDATION,
    SEGMENTATION, REGEX
    """


class MonitorSamplingConfigInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("percentage", "count")
    percentage = sgqlc.types.Field(Float, graphql_name="percentage")

    count = sgqlc.types.Field(Int, graphql_name="count")


class MonitorSelectExpressionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("expression", "data_type")
    expression = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="expression")
    """SQL select expression, could be a raw column name or a more
    complex expression
    """

    data_type = sgqlc.types.Field(String, graphql_name="dataType")
    """Data type of expression. Required if expression is a complex
    expression and not a raw column name
    """


class MonitoredTableRuleInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "is_exclude",
        "rule_type",
        "table_rule_text",
        "table_rule_attribute",
        "id",
        "monitored_rule_type",
    )
    is_exclude = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExclude")
    """Whether the rule is an exclusion rule"""

    rule_type = sgqlc.types.Field(MonitoredTableRuleType, graphql_name="ruleType")
    """Deprecated, use monitored_rule_type"""

    table_rule_text = sgqlc.types.Field(String, graphql_name="tableRuleText")
    """The rule. If rule_type=ALL, this field must be empty.If the rule
    is a tag rule, this field must be a JSON string. Construct the
    tags in this format: If tags are 'monitor' and 'importance:high'
    (where monitor & importance are the propertyName and null & high
    are the propertyValue. See
    [ObjectProperty]({{Types.ObjectProperty}})), then pass in
    '[["monitor",null],["name","value"]]'
    """

    table_rule_attribute = sgqlc.types.Field(
        MonitoredTableRuleTableAttribute, graphql_name="tableRuleAttribute"
    )
    """Table attribute to match against. Omit if rule_type=ALL. If
    rule_type != ALL, and this field is omitted, by default the rule
    will match against table_id.
    """

    id = sgqlc.types.Field(String, graphql_name="id")
    """ID of the rule. If provided, the rule will be updated instead of
    created.
    """

    monitored_rule_type = sgqlc.types.Field(MonitoredRuleType, graphql_name="monitoredRuleType")
    """Monitoring rule type"""


class MonteCarloStatusMappingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("servicenow_incident_state", "incident_feedback")
    servicenow_incident_state = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="servicenowIncidentState"
    )

    incident_feedback = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="incidentFeedback",
    )


class MskKafkaConnectCredentialsInput(sgqlc.types.Input):
    """Credentials for MSK Kafka Connect"""

    __schema__ = schema
    __field_names__ = ("cluster_arn", "iam_role_arn", "external_id")
    cluster_arn = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clusterArn")
    """ARN of the MSK cluster that connectors are running against"""

    iam_role_arn = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="iamRoleArn")
    """ARN of an assumable IAM role used for collection, see our public
    docs for required permissions
    """

    external_id = sgqlc.types.Field(String, graphql_name="externalId")
    """Optional external id, if one is required to assume the provided
    IAM role
    """


class NodeInput(sgqlc.types.Input):
    """Minimal information to identify a node"""

    __schema__ = schema
    __field_names__ = ("object_type", "object_id", "resource_id", "resource_name")
    object_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="objectType")
    """Object type"""

    object_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="objectId")
    """Object identifier"""

    resource_id = sgqlc.types.Field(UUID, graphql_name="resourceId")
    """The id of the resource containing the node"""

    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """The name of the resource containing the node"""


class NotificationDigestSettings(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("start_time", "interval_minutes", "digest_type")
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of scheduled digest. If not set, by default it is UTC
    00:00 daily
    """

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Interval of how frequently to run the schedule. If not set, by
    default it is 1440 minutes(24h)
    """

    digest_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="digestType")
    """Type of digest. Supported options include: anomalies_digest,
    misconf_digest, inactive_digest
    """


class NotificationExtra(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "slack_is_private",
        "webhook_shared_secret",
        "webhook_encrypted_secret",
        "team_id",
        "team_name",
        "priority",
        "url",
        "username",
        "password",
        "dc_proxy",
        "turn_off_normalized_messages",
        "receive_normalized",
        "disable_ssl_verification",
        "include_incident_fields",
        "jira_project_id",
        "jira_issue_type_id",
        "pd_severity_error",
        "ado_project",
        "ado_work_item_type",
        "schema_version",
    )
    slack_is_private = sgqlc.types.Field(Boolean, graphql_name="slackIsPrivate")
    """Skip attempting to join if the channel is private. Requires a
    channel invitation first
    """

    webhook_shared_secret = sgqlc.types.Field(String, graphql_name="webhookSharedSecret")
    """An optional shared signing secret to use for validating the
    integrity of information when using a webhook integration
    """

    webhook_encrypted_secret = sgqlc.types.Field(String, graphql_name="webhookEncryptedSecret")
    """This field should be provided by the frontend when an update is
    being done to the notification setting and a shared secret key
    already existed for the web hook
    """

    team_id = sgqlc.types.Field(String, graphql_name="teamId")
    """The team ID to use when sending notifications to a Slack workspace"""

    team_name = sgqlc.types.Field(String, graphql_name="teamName")
    """The team ID to use when sending notifications to a Slack workspace"""

    priority = sgqlc.types.Field(String, graphql_name="priority")
    """Priority in remote notification system (Opsgenie)"""

    url = sgqlc.types.Field(String, graphql_name="url")
    """API URL (Opsgenie, use this for regional URLs)"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """Username for external notification integration"""

    password = sgqlc.types.Field(String, graphql_name="password")
    """Password for external notification integration"""

    dc_proxy = sgqlc.types.Field(Boolean, graphql_name="dcProxy")
    """True if HTTP requests should be proxied through the Data Collector"""

    turn_off_normalized_messages = sgqlc.types.Field(
        Boolean, graphql_name="turnOffNormalizedMessages"
    )
    """True if normalized messages need to be turned off. DEPRECATED: Use
    receiveNormalized instead.
    """

    receive_normalized = sgqlc.types.Field(Boolean, graphql_name="receiveNormalized")
    """True if normalized messages should be received"""

    disable_ssl_verification = sgqlc.types.Field(Boolean, graphql_name="disableSslVerification")
    """True if HTTP requests proxied through the Data Collector should
    not verify SSL certificates
    """

    include_incident_fields = sgqlc.types.Field(JSONString, graphql_name="includeIncidentFields")
    """Field-value pairs to include as additional fields (when creating
    incidents in ServiceNow, Datadog or JIRA)
    """

    jira_project_id = sgqlc.types.Field(Int, graphql_name="jiraProjectId")
    """Project Id for Jira"""

    jira_issue_type_id = sgqlc.types.Field(Int, graphql_name="jiraIssueTypeId")
    """Issue Type Id for Jira"""

    pd_severity_error = sgqlc.types.Field(Boolean, graphql_name="pdSeverityError")
    """True if must send events to PagerDuty with severity error, for
    high urgency incidents
    """

    ado_project = sgqlc.types.Field(String, graphql_name="adoProject")
    """Project name for Azure DevOps"""

    ado_work_item_type = sgqlc.types.Field(String, graphql_name="adoWorkItemType")
    """Work item type for Azure DevOps (Bug, Task, Issue, etc.)"""

    schema_version = sgqlc.types.Field(String, graphql_name="schemaVersion")
    """Version of the notification settings schema"""


class NotificationRoutingRules(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "project_names",
        "project_mcons",
        "dataset_ids",
        "full_table_ids",
        "table_mcons",
        "rule_ids",
        "domain_ids",
        "tag_keys",
        "tag_key_values",
        "all_tag_key_values",
        "table_stats_rules",
        "monitor_labels",
        "monitor_labels_match_type",
        "exclude_project_names",
        "exclude_project_mcons",
        "exclude_dataset_ids",
        "exclude_full_table_ids",
        "exclude_table_mcons",
        "exclude_tag_keys",
        "exclude_tag_key_values",
        "exclude_all_tag_key_values",
        "table_regex",
    )
    project_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="projectNames")
    """Allowlist by project names"""

    project_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="projectMcons")
    """Allowlist by project mcons"""

    dataset_ids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="datasetIds")
    """Allowlist by dataset identifiers"""

    full_table_ids = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fullTableIds")
    """Allowlist by full table identifiers"""

    table_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tableMcons")
    """Allowlist by table mcons"""

    rule_ids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="ruleIds")
    """Allowlist by rule identifiers"""

    domain_ids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="domainIds")
    """Allowlist by domain identifiers"""

    tag_keys = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tagKeys")
    """Allowlist by tag keys"""

    tag_key_values = sgqlc.types.Field(
        sgqlc.types.list_of("NotificationTagPairs"), graphql_name="tagKeyValues"
    )
    """Allowlist by tag key/value pairs"""

    all_tag_key_values = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.list_of("NotificationTagPairs")),
        graphql_name="allTagKeyValues",
    )

    table_stats_rules = sgqlc.types.Field("TableStatsRules", graphql_name="tableStatsRules")
    """Allowlist by table stats (importance_score, is_important)."""

    monitor_labels = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="monitorLabels")
    """Allowlist by monitor labels"""

    monitor_labels_match_type = sgqlc.types.Field(
        MonitorLabelsMatchType, graphql_name="monitorLabelsMatchType"
    )
    """Logic operator for matching labels. Defaults to OR."""

    exclude_project_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="excludeProjectNames"
    )
    """Denylist by project names"""

    exclude_project_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="excludeProjectMcons"
    )
    """Denylist by project mcons"""

    exclude_dataset_ids = sgqlc.types.Field(
        sgqlc.types.list_of(UUID), graphql_name="excludeDatasetIds"
    )
    """Denylist by dataset identifiers"""

    exclude_full_table_ids = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="excludeFullTableIds"
    )
    """Denylist by full table identifiers"""

    exclude_table_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="excludeTableMcons"
    )
    """Denylist by table mcon identifiers"""

    exclude_tag_keys = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="excludeTagKeys")
    """Denylist by tag keys"""

    exclude_tag_key_values = sgqlc.types.Field(
        sgqlc.types.list_of("NotificationTagPairs"), graphql_name="excludeTagKeyValues"
    )
    """Denylist by tag key/value pairs"""

    exclude_all_tag_key_values = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.list_of("NotificationTagPairs")),
        graphql_name="excludeAllTagKeyValues",
    )

    table_regex = sgqlc.types.Field(String, graphql_name="tableRegex")
    """For use in updating regex based rules"""


class NotificationTagPairs(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Tag key"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Tag Value"""


class NumericFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "ranges")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")
    """Field name to filter on"""

    ranges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("NumericRangeInput")), graphql_name="ranges"
    )
    """Numeric ranges to filter by (combined via OR)"""


class NumericRangeInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("lower_bound_value", "upper_bound_value")
    lower_bound_value = sgqlc.types.Field(Int, graphql_name="lowerBoundValue")
    """Numeric range end value"""

    upper_bound_value = sgqlc.types.Field(Int, graphql_name="upperBoundValue")
    """Numeric range start value"""


class OAuthConfiguration(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "client_id",
        "client_secret",
        "grant_type",
        "access_token_endpoint",
        "scope",
        "username",
        "password",
    )
    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")
    """Oauth Client ID"""

    client_secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientSecret")
    """Oauth Client Secret"""

    grant_type = sgqlc.types.Field(
        sgqlc.types.non_null(OAuthGrantTypeEnum), graphql_name="grantType"
    )
    """OAuth Grant type. Can be one of (client_credentials, password)"""

    access_token_endpoint = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="accessTokenEndpoint"
    )
    """OAuth endpoint used to acquire access tokens"""

    scope = sgqlc.types.Field(String, graphql_name="scope")
    """OAuth Scope"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """OAuth Username for oauth password grant flow"""

    password = sgqlc.types.Field(String, graphql_name="password")
    """OAuth Password for oauth password grant flow"""


class ObjectPropertyInput(sgqlc.types.Input):
    """Object properties, indexed by the search service"""

    __schema__ = schema
    __field_names__ = ("property_name", "property_value")
    property_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="propertyName")
    """The name (key) of the property"""

    property_value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="propertyValue")
    """The value for the property"""


class PiiFilterStatusPair(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("filter_name", "enabled")
    filter_name = sgqlc.types.Field(String, graphql_name="filterName")
    """The unique name of the PII filter."""

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Whether the PII filter should be enabled or not."""


class PineconeConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("environment", "project_id", "api_key")
    environment = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="environment")
    """Identifier of Pinecone environment (e.g. us-east-1-aws)."""

    project_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="projectId")
    """Identifier of Pinecone project."""

    api_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="apiKey")
    """API key for Pinecone project."""


class PineconeUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("environment", "project_id", "api_key")
    environment = sgqlc.types.Field(String, graphql_name="environment")
    """Identifier of Pinecone environment (e.g. us-east-1-aws)."""

    project_id = sgqlc.types.Field(String, graphql_name="projectId")
    """Identifier of Pinecone project."""

    api_key = sgqlc.types.Field(String, graphql_name="apiKey")
    """API key for Pinecone project."""


class PowerBIConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "tenant_id",
        "auth_mode",
        "client_id",
        "client_secret",
        "username",
        "password",
    )
    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")
    """Azure Power BI tenant uuid"""

    auth_mode = sgqlc.types.Field(
        sgqlc.types.non_null(PowerBIAuthModeEnumV2), graphql_name="authMode"
    )
    """Authentication mode. We support two values here
    [service_principal, primary_user]
    """

    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")
    """App Client UUID"""

    client_secret = sgqlc.types.Field(String, graphql_name="clientSecret")
    """Secret key for the client ID. Required if auth_mode is
    service_principal.
    """

    username = sgqlc.types.Field(String, graphql_name="username")
    """Username when auth as a primary user. Required if auth_mode is
    primary_user.
    """

    password = sgqlc.types.Field(String, graphql_name="password")
    """Password when auth as a primary user. Required if auth_mode is
    primary_user.
    """


class PowerBiUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "tenant_id",
        "auth_mode",
        "client_id",
        "client_secret",
        "username",
        "password",
    )
    tenant_id = sgqlc.types.Field(String, graphql_name="tenantId")
    """Azure Power BI tenant uuid"""

    auth_mode = sgqlc.types.Field(
        sgqlc.types.non_null(PowerBIUpdateAuthModeEnumV2), graphql_name="authMode"
    )
    """Authentication mode. We support two values here
    [service_principal, primary_user]
    """

    client_id = sgqlc.types.Field(String, graphql_name="clientId")
    """App Client UUID"""

    client_secret = sgqlc.types.Field(String, graphql_name="clientSecret")
    """Secret key for the client ID. Required if auth_mode is
    service_principal.
    """

    username = sgqlc.types.Field(String, graphql_name="username")
    """Username when auth as a primary user. Required if auth_mode is
    primary_user.
    """

    password = sgqlc.types.Field(String, graphql_name="password")
    """Password when auth as a primary user. Required if auth_mode is
    primary_user.
    """


class ProjectFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("project_mcons",)
    project_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="projectMcons")
    """MCONs of projects to filter by."""


class PullRequestFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("filter_name", "values")
    filter_name = sgqlc.types.Field(PullRequestFilterName, graphql_name="filterName")
    """Name of the filter"""

    values = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="values")
    """Values and counts of the filter"""


class QPMonitorConfigInputType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("metadata", "comparisons")
    metadata = sgqlc.types.Field(
        sgqlc.types.non_null("QuerySelectionInput"), graphql_name="metadata"
    )
    """Query selection"""

    comparisons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
        graphql_name="comparisons",
    )
    """Comparisons"""


class QueryLogsFacetRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "field_name",
        "search_criteria",
        "apply_mask",
        "first",
        "search_prefix",
        "included_query_types",
    )
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field name"""

    search_criteria = sgqlc.types.Field("SearchCriteriaType", graphql_name="searchCriteria")

    apply_mask = sgqlc.types.Field(Boolean, graphql_name="applyMask")
    """Apply mask"""

    first = sgqlc.types.Field(Int, graphql_name="first")
    """First"""

    search_prefix = sgqlc.types.Field(String, graphql_name="searchPrefix")
    """Search facets by prefix"""

    included_query_types = sgqlc.types.Field(
        sgqlc.types.list_of(QueryLogType), graphql_name="includedQueryTypes"
    )
    """The query log types we want to include in the time series
    aggregation. The options are [READ], [WRITE] or [READ, WRITE]
    """


class QueryLogsFacetRequestTypeV2(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("requests",)
    requests = sgqlc.types.Field(
        sgqlc.types.list_of(QueryLogsFacetRequestType), graphql_name="requests"
    )


class QueryLogsRequestInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "search_criteria",
        "query_group_field",
        "query_runtime_field",
        "sort_field",
        "sort_order",
        "first",
        "offset",
        "included_query_types",
    )
    search_criteria = sgqlc.types.Field(
        sgqlc.types.non_null("SearchCriteriaType"), graphql_name="searchCriteria"
    )

    query_group_field = sgqlc.types.Field(String, graphql_name="queryGroupField")

    query_runtime_field = sgqlc.types.Field(String, graphql_name="queryRuntimeField")

    sort_field = sgqlc.types.Field(String, graphql_name="sortField")

    sort_order = sgqlc.types.Field(String, graphql_name="sortOrder")

    first = sgqlc.types.Field(Int, graphql_name="first")

    offset = sgqlc.types.Field(Int, graphql_name="offset")

    included_query_types = sgqlc.types.Field(
        sgqlc.types.list_of(QueryLogType), graphql_name="includedQueryTypes"
    )
    """Query types to include in the results. Can be READ, WRITE or both.
    By default it will use WRITE
    """


class QueryPerformanceDataRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("search_criteria", "query_group_values", "time_bucket_size", "metrics")
    search_criteria = sgqlc.types.Field("SearchCriteriaType", graphql_name="searchCriteria")
    """Query search criteria"""

    query_group_values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="queryGroupValues"
    )
    """Query group identifiers"""

    time_bucket_size = sgqlc.types.Field(String, graphql_name="timeBucketSize")
    """Size of time buckets"""

    metrics = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(MetricAggregationInputType)),
        graphql_name="metrics",
    )
    """Metric aggregations"""


class QueryRuntimePercentileTimeSeriesRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("search_criteria", "time_bucket_size", "percentiles", "included_query_types")
    search_criteria = sgqlc.types.Field("SearchCriteriaType", graphql_name="searchCriteria")

    time_bucket_size = sgqlc.types.Field(String, graphql_name="timeBucketSize")

    percentiles = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(Int)), graphql_name="percentiles"
    )
    """Each time series returned will be for a given percentile. Examples
    are: 50, 75, 95. 99, 100
    """

    included_query_types = sgqlc.types.Field(
        sgqlc.types.list_of(QueryLogType), graphql_name="includedQueryTypes"
    )
    """The query log types we want to include in the time series
    aggregation. The options are [READ], [WRITE] or [READ, WRITE]
    """


class QuerySelectionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("query_type", "indexed_field_filters")
    query_type = sgqlc.types.Field(sgqlc.types.non_null(QueryLogType), graphql_name="queryType")
    """Type of the monitored queries"""

    indexed_field_filters = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(IndexedFieldFilterType)),
        graphql_name="indexedFieldFilters",
    )
    """Selection criteria of the monitored queries"""


class QueryTemplateVariableValueInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "value", "value_json")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Variable name"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Variable value"""

    value_json = sgqlc.types.Field(JSONString, graphql_name="valueJson")
    """Variable value (in JSON)"""


class RedshiftConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("db_name", "host", "port", "user", "password")
    db_name = sgqlc.types.Field(String, graphql_name="dbName")
    """Name of database to add connection for"""

    host = sgqlc.types.Field(String, graphql_name="host")
    """Hostname of the warehouse"""

    port = sgqlc.types.Field(Int, graphql_name="port")
    """HTTP Port to use"""

    user = sgqlc.types.Field(String, graphql_name="user")
    """User with access to the database"""

    password = sgqlc.types.Field(String, graphql_name="password")
    """User's password"""


class RedshiftUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("db_name", "host", "port", "user", "password")
    db_name = sgqlc.types.Field(String, graphql_name="dbName")
    """Name of database to add connection for"""

    host = sgqlc.types.Field(String, graphql_name="host")
    """Hostname of the warehouse"""

    port = sgqlc.types.Field(Int, graphql_name="port")
    """HTTP Port to use"""

    user = sgqlc.types.Field(String, graphql_name="user")
    """User with access to the database"""

    password = sgqlc.types.Field(String, graphql_name="password")
    """User's password"""


class ReportArgumentsUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("alert_id", "monitor_id", "type")
    alert_id = sgqlc.types.Field(UUID, graphql_name="alertId")

    monitor_id = sgqlc.types.Field(UUID, graphql_name="monitorId")

    type = sgqlc.types.Field(sgqlc.types.non_null(ReportTypeEnum), graphql_name="type")


class RetrieveTableDataRequestInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dataset", "order_by", "limit")
    dataset = sgqlc.types.Field(sgqlc.types.non_null(DatasetInput), graphql_name="dataset")

    order_by = sgqlc.types.Field(String, graphql_name="orderBy")

    limit = sgqlc.types.Field(Int, graphql_name="limit")


class RetrieveWidgetDataRequestInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "dataset",
        "widget_type",
        "field_name",
        "limit",
        "offset",
        "config",
        "widget_config",
    )
    dataset = sgqlc.types.Field(sgqlc.types.non_null(DatasetInput), graphql_name="dataset")

    widget_type = sgqlc.types.Field(sgqlc.types.non_null(WidgetType), graphql_name="widgetType")

    field_name = sgqlc.types.Field(String, graphql_name="fieldName")

    limit = sgqlc.types.Field(Int, graphql_name="limit")

    offset = sgqlc.types.Field(Int, graphql_name="offset")

    config = sgqlc.types.Field(JSONString, graphql_name="config")
    """DEPRECATED - use widget_config"""

    widget_config = sgqlc.types.Field("WidgetConfig", graphql_name="widgetConfig")
    """Widget configuration"""


class RuntimeVariableValueInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")


class ScheduleConfigInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "schedule_type",
        "interval_minutes",
        "dynamic_schedule_mcons",
        "interval_crontab",
        "interval_crontab_day_or",
        "start_time",
        "min_interval_minutes",
        "timezone",
    )
    schedule_type = sgqlc.types.Field(
        sgqlc.types.non_null(ScheduleType), graphql_name="scheduleType"
    )
    """Type of schedule"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Time interval between job executions, in minutes"""

    dynamic_schedule_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="dynamicScheduleMcons"
    )
    """Mcons of tables to trigger schedule on update"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Time interval between job executions, using a cron expression"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """For schedule_type=fixed, the date the schedule should start"""

    min_interval_minutes = sgqlc.types.Field(Int, graphql_name="minIntervalMinutes")
    """For schedule_type=dynamic, the minimum time interval between job
    executions
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions."""


class SchemaFieldInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "type", "mode", "nested", "sql_name", "main_type")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

    mode = sgqlc.types.Field(FieldMode, graphql_name="mode")

    nested = sgqlc.types.Field(Boolean, graphql_name="nested")

    sql_name = sgqlc.types.Field(String, graphql_name="sqlName")

    main_type = sgqlc.types.Field(FieldType, graphql_name="mainType")


class SearchCriteriaType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "indexed_field_filters",
        "query_group",
        "start_time",
        "end_time",
        "query_group_field",
        "query_ids",
        "require_runtime_field",
    )
    indexed_field_filters = sgqlc.types.Field(
        sgqlc.types.list_of(IndexedFieldFilterType), graphql_name="indexedFieldFilters"
    )
    """List of indexed field filters"""

    query_group = sgqlc.types.Field(String, graphql_name="queryGroup")

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """start time, overrides days_back"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """end time, overrides days_back"""

    query_group_field = sgqlc.types.Field(String, graphql_name="queryGroupField")

    query_ids = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="queryIds")
    """List of query ids"""

    require_runtime_field = sgqlc.types.Field(Boolean, graphql_name="requireRuntimeField")
    """When set, only return queries with the execution_time_ms_l field
    present
    """


class SegmentCountQueryInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "connection_id",
        "data_source",
        "mcon",
        "segmented_expressions",
        "time_axis_name",
        "time_axis_type",
        "agg_time_interval",
        "lookback_days",
        "where_condition",
        "preview",
    )
    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """Connection UUID to use for the query"""

    data_source = sgqlc.types.Field(DataSourceUnionInput, graphql_name="dataSource")
    """Target data source"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Mcon of the target table"""

    segmented_expressions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="segmentedExpressions",
    )
    """Segmentation fields/expressions"""

    time_axis_name = sgqlc.types.Field(String, graphql_name="timeAxisName")
    """Time axis name"""

    time_axis_type = sgqlc.types.Field(String, graphql_name="timeAxisType")
    """Time axis type"""

    agg_time_interval = sgqlc.types.Field(MonitorAggTimeInterval, graphql_name="aggTimeInterval")
    """Aggregation time interval to use. (defaults to HOUR)"""

    lookback_days = sgqlc.types.Field(Int, graphql_name="lookbackDays")
    """History days for the monitor"""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """WHERE condition to apply to the query"""

    preview = sgqlc.types.Field(Boolean, graphql_name="preview")
    """Whether query fetches a preview of segments instead of a total
    count
    """


class SegmentsFilter(sgqlc.types.Input):
    """A segment key and its value"""

    __schema__ = schema
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """The segment name"""

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """Value of the segment"""


class SelfHostedCredentialsConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "connection_type",
        "self_hosted_credentials_type",
        "decryption_service_type",
        "env_var_name",
        "kms_key_id",
        "aws_secret",
        "gcp_secret",
        "akv_vault_name",
        "akv_vault_url",
        "akv_secret",
        "aws_region",
        "assumable_role",
        "external_id",
    )
    connection_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="connectionType")
    """Connection type to test credentials for (e.g. 'snowflake')"""

    self_hosted_credentials_type = sgqlc.types.Field(
        sgqlc.types.non_null(SelfHostedCredentialsTypeEnum),
        graphql_name="selfHostedCredentialsType",
    )
    """Self-hosted credentials type (e.g. 'env_var',
    'aws_secrets_manager')
    """

    decryption_service_type = sgqlc.types.Field(
        DecryptionServiceTypeEnum, graphql_name="decryptionServiceType"
    )
    """Optional type of service used to decrypt environment variable
    credentials (e.g. 'kms'). Required when
    self_hosted_credentials_type is 'env_var'.
    """

    env_var_name = sgqlc.types.Field(String, graphql_name="envVarName")
    """Name of environment variable containing credentials. Required when
    self_hosted_credentials_type is 'env_var'.
    """

    kms_key_id = sgqlc.types.Field(String, graphql_name="kmsKeyId")
    """Optional KMS key id for decrypting environment variable
    credentials. Required when decryption_service_type is 'kms'.
    """

    aws_secret = sgqlc.types.Field(String, graphql_name="awsSecret")
    """ARN or name of AWS Secret Manager secret containing credentials.
    Required when self_hosted_credentials_type is
    'aws_secrets_manager'.
    """

    gcp_secret = sgqlc.types.Field(String, graphql_name="gcpSecret")
    """Name of GCP Secret Manager secret containing credentials. Required
    when self_hosted_credentials_type is 'gcp_secrets_manager'.
    """

    akv_vault_name = sgqlc.types.Field(String, graphql_name="akvVaultName")
    """Name of Azure Key Vault containing credentials. Required when
    self_hosted_credentials_type is 'azure_key_vault' and
    'akv_vault_url' is not provided.
    """

    akv_vault_url = sgqlc.types.Field(String, graphql_name="akvVaultUrl")
    """URL of Azure Key Vault containing credentials. Required when
    self_hosted_credentials_type is 'azure_key_vault' and
    'akv_vault_name' is not provided.
    """

    akv_secret = sgqlc.types.Field(String, graphql_name="akvSecret")
    """Name of Azure Key Vault secret containing credentials. Required
    when self_hosted_credentials_type is 'azure_key_vault'.
    """

    aws_region = sgqlc.types.Field(String, graphql_name="awsRegion")
    """Optional AWS region to access ASM secret or KMS key"""

    assumable_role = sgqlc.types.Field(String, graphql_name="assumableRole")
    """Optional ARN of AWS role to assume when accessing secret manager
    secret or KMS key
    """

    external_id = sgqlc.types.Field(String, graphql_name="externalId")
    """Optional external id for AWS assumable role"""


class SelfHostedKafkaConnectCredentialsInput(sgqlc.types.Input):
    """Credentials to a Self Hosted Kafka Cluster"""

    __schema__ = schema
    __field_names__ = ("cluster", "auth_type", "auth_token", "url")
    cluster = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cluster")
    """Self Hosted Kafka Connect cluster."""

    auth_type = sgqlc.types.Field(sgqlc.types.non_null(AuthType), graphql_name="authType")
    """Type of Auth used to connect to the cluster."""

    auth_token = sgqlc.types.Field(String, graphql_name="authToken")
    """Authentication Token. Required for Basic and Bearer Auth."""

    url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="url")
    """URL for the Self Hosted kafka connect cluster."""


class SelfHostedKafkaCredentialsInput(sgqlc.types.Input):
    """Credentials to a Self Hosted Kafka Cluster"""

    __schema__ = schema
    __field_names__ = ("cluster", "auth_type", "auth_token", "url")
    cluster = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cluster")
    """Self Hosted Kafka cluster."""

    auth_type = sgqlc.types.Field(sgqlc.types.non_null(AuthType), graphql_name="authType")
    """Type of Auth used to connect to the cluster."""

    auth_token = sgqlc.types.Field(String, graphql_name="authToken")
    """Authentication Token. Required for Basic and Bearer Auth."""

    url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="url")
    """URL for the Self Hosted kafka cluster."""


class SelfHostedUpdateCredentialsConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "self_hosted_credentials_type",
        "decryption_service_type",
        "env_var_name",
        "kms_key_id",
        "aws_secret",
        "aws_region",
        "assumable_role",
        "external_id",
    )
    self_hosted_credentials_type = sgqlc.types.Field(
        SelfHostedUpdateCredentialsTypeEnum, graphql_name="selfHostedCredentialsType"
    )
    """Self-hosted credentials type (e.g. 'env_var',
    'aws_secrets_manager')
    """

    decryption_service_type = sgqlc.types.Field(
        DecryptionServiceUpdateTypeEnum, graphql_name="decryptionServiceType"
    )
    """Optional type of service used to decrypt environment variable
    credentials (e.g. 'kms'). Required when
    self_hosted_credentials_type is 'env_var'.
    """

    env_var_name = sgqlc.types.Field(String, graphql_name="envVarName")
    """Name of environment variable containing credentials. Required when
    self_hosted_credentials_type is 'env_var'.
    """

    kms_key_id = sgqlc.types.Field(String, graphql_name="kmsKeyId")
    """Optional KMS key id for decrypting environment variable
    credentials. Required when decryption_service_type is 'kms'.
    """

    aws_secret = sgqlc.types.Field(String, graphql_name="awsSecret")
    """ARN or name of AWS Secret Manager secret containing credentials.
    Required when self_hosted_credentials_type is
    'aws_secrets_manager'.
    """

    aws_region = sgqlc.types.Field(String, graphql_name="awsRegion")
    """Optional AWS region to access ASM secret or KMS key"""

    assumable_role = sgqlc.types.Field(String, graphql_name="assumableRole")
    """Optional ARN of AWS role to assume when accessing secret manager
    secret or KMS key
    """

    external_id = sgqlc.types.Field(String, graphql_name="externalId")
    """Optional external id for AWS assumable role"""


class SensitivityInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("level",)
    level = sgqlc.types.Field(SensitivityLevels, graphql_name="level")
    """Low, medium or high sensitivity"""


class ServiceNowCredentialsUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("username", "password", "client_id", "client_secret", "type")
    username = sgqlc.types.Field(String, graphql_name="username")

    password = sgqlc.types.Field(String, graphql_name="password")

    client_id = sgqlc.types.Field(String, graphql_name="clientId")

    client_secret = sgqlc.types.Field(String, graphql_name="clientSecret")

    type = sgqlc.types.Field(sgqlc.types.non_null(ServiceNowCredentialsType), graphql_name="type")


class ServiceNowIntegrationOptionsInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "oauth_token_endpoint",
        "api_base_url",
        "incident_link_url_pattern",
        "supports_user_table",
        "supports_fetch_fields",
        "supports_fetch_incident",
        "set_description_field",
        "status_mappings",
    )
    oauth_token_endpoint = sgqlc.types.Field(String, graphql_name="oauthTokenEndpoint")

    api_base_url = sgqlc.types.Field(String, graphql_name="apiBaseUrl")

    incident_link_url_pattern = sgqlc.types.Field(String, graphql_name="incidentLinkUrlPattern")

    supports_user_table = sgqlc.types.Field(Boolean, graphql_name="supportsUserTable")

    supports_fetch_fields = sgqlc.types.Field(Boolean, graphql_name="supportsFetchFields")

    supports_fetch_incident = sgqlc.types.Field(Boolean, graphql_name="supportsFetchIncident")

    set_description_field = sgqlc.types.Field(Boolean, graphql_name="setDescriptionField")

    status_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(MonteCarloStatusMappingInput)),
        graphql_name="statusMappings",
    )


class ServiceNowStateMappingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("incident_feedback", "servicenow_incident_state")
    incident_feedback = sgqlc.types.Field(String, graphql_name="incidentFeedback")
    """('The feedback that will be set on the Monte Carlo incident if the
    ServiceNow incident is set to any of the provided ServiceNow
    statuses',)
    """

    servicenow_incident_state = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="servicenowIncidentState"
    )
    """The ServiceNow states that will map to the Monte Carlo incident
    feedback
    """


class ServiceNowWebhookConfigInput(sgqlc.types.Input):
    """ServiceNow webhook config"""

    __schema__ = schema
    __field_names__ = ("state_mappings",)
    state_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(ServiceNowStateMappingInput), graphql_name="stateMappings"
    )
    """Mapping FROM ServiceNow incident states TO Monte Carlo alert
    status
    """


class SetIncidentFeedbackInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("incident_id", "feedback", "client_mutation_id")
    incident_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="incidentId")
    """UUID of incident to add feedback"""

    feedback = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="feedback")
    """The feedback to be added to an incident"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class SetIncidentFeedbackV2Input(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("incident_id", "feedback", "client_mutation_id")
    incident_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="incidentId")
    """UUID of incident to add feedback"""

    feedback = sgqlc.types.Field(sgqlc.types.non_null(IncidentFeedback), graphql_name="feedback")
    """The feedback to be added to an incident"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class SimulateMonitorEvaluationRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("evaluation_start_time", "evaluation_end_time", "limit")
    evaluation_start_time = sgqlc.types.Field(DateTime, graphql_name="evaluationStartTime")
    """Evaluation start time"""

    evaluation_end_time = sgqlc.types.Field(DateTime, graphql_name="evaluationEndTime")
    """Evaluation end time"""

    limit = sgqlc.types.Field(Int, graphql_name="limit")
    """Number of breaching query groups to return"""


class SnowflakeConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "user",
        "private_key",
        "private_key_passphrase",
        "account",
        "warehouse",
        "oauth",
    )
    user = sgqlc.types.Field(String, graphql_name="user")
    """User with access to snowflake."""

    private_key = sgqlc.types.Field(String, graphql_name="privateKey")
    """User's private key (base64 encoded)."""

    private_key_passphrase = sgqlc.types.Field(String, graphql_name="privateKeyPassphrase")
    """User's private key passphrase. This argument is only needed when
    the private key is encrypted.
    """

    account = sgqlc.types.Field(String, graphql_name="account")
    """Snowflake account name"""

    warehouse = sgqlc.types.Field(String, graphql_name="warehouse")
    """Name of the warehouse for the user"""

    oauth = sgqlc.types.Field(OAuthConfiguration, graphql_name="oauth")
    """Configuration for OAuth for Snowflake."""


class SnowflakeUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "user",
        "password",
        "private_key",
        "private_key_passphrase",
        "account",
        "warehouse",
        "oauth",
    )
    user = sgqlc.types.Field(String, graphql_name="user")
    """User with access to snowflake."""

    password = sgqlc.types.Field(String, graphql_name="password")
    """User's password if using user/password basic auth"""

    private_key = sgqlc.types.Field(String, graphql_name="privateKey")
    """User's private key (base64 encoded) if using key pair auth."""

    private_key_passphrase = sgqlc.types.Field(String, graphql_name="privateKeyPassphrase")
    """User's private key passphrase if using key pair auth. This
    argument is only needed when the private key is encrypted.
    """

    account = sgqlc.types.Field(String, graphql_name="account")
    """Snowflake account name"""

    warehouse = sgqlc.types.Field(String, graphql_name="warehouse")
    """Name of the warehouse for the user"""

    oauth = sgqlc.types.Field(OAuthConfiguration, graphql_name="oauth")
    """Configuration for OAuth for Snowflake."""


class SparkBinaryInput(sgqlc.types.Input):
    """Credentials to the Spark  Thrift server in binary mode"""

    __schema__ = schema
    __field_names__ = ("database", "host", "port", "username", "password")
    database = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="database")
    """Database name"""

    host = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="host")
    """Host name"""

    port = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="port")
    """Port"""

    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")
    """User name"""

    password = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="password")
    """Password"""


class SparkHttpInput(sgqlc.types.Input):
    """Credentials to the Spark  Thrift server in HTTP mode"""

    __schema__ = schema
    __field_names__ = ("url", "username", "password")
    url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="url")
    """Connection URL to the Thrift server"""

    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")
    """User name"""

    password = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="password")
    """Password"""


class SslInputOptions(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("ca", "ca_data", "cert", "key", "mechanism", "skip_verification")
    ca = sgqlc.types.Field(String, graphql_name="ca")
    """CA bundle file"""

    ca_data = sgqlc.types.Field(String, graphql_name="caData")
    """CA certificate data to use for the connection"""

    cert = sgqlc.types.Field(String, graphql_name="cert")
    """Certificate file"""

    key = sgqlc.types.Field(String, graphql_name="key")
    """Key file"""

    mechanism = sgqlc.types.Field(String, graphql_name="mechanism")
    """How the file is passed to the DC. Possible values are: "dc-s3" or
    "url"
    """

    skip_verification = sgqlc.types.Field(Boolean, graphql_name="skipVerification")
    """Whether SSL certificate verification should be skipped"""


class SslOptions(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "ca_data",
        "cert_data",
        "key_data",
        "key_password",
        "disabled",
        "verify_cert",
        "verify_identity",
        "skip_cert_verification",
    )
    ca_data = sgqlc.types.Field(String, graphql_name="caData")
    """SSL CA certificate data to use for the connection"""

    cert_data = sgqlc.types.Field(String, graphql_name="certData")
    """SSL certificate data to use for the connection"""

    key_data = sgqlc.types.Field(String, graphql_name="keyData")
    """SSL key data to use for the connection"""

    key_password = sgqlc.types.Field(String, graphql_name="keyPassword")
    """SSL key password to use for the connection"""

    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Disables usage of TLS."""

    verify_cert = sgqlc.types.Field(Boolean, graphql_name="verifyCert")
    """Set to true to check the server certificate’s validity"""

    verify_identity = sgqlc.types.Field(Boolean, graphql_name="verifyIdentity")
    """Verify the server's identity"""

    skip_cert_verification = sgqlc.types.Field(Boolean, graphql_name="skipCertVerification")
    """Skip certificate verification"""


class SslUpdateOptions(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "ca_data",
        "cert_data",
        "key_data",
        "key_password",
        "disabled",
        "verify_cert",
        "verify_identity",
        "skip_cert_verification",
    )
    ca_data = sgqlc.types.Field(String, graphql_name="caData")
    """SSL CA certificate data to use for the connection"""

    cert_data = sgqlc.types.Field(String, graphql_name="certData")
    """SSL certificate data to use for the connection"""

    key_data = sgqlc.types.Field(String, graphql_name="keyData")
    """SSL key data to use for the connection"""

    key_password = sgqlc.types.Field(String, graphql_name="keyPassword")
    """SSL key password to use for the connection"""

    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Disables usage of TLS."""

    verify_cert = sgqlc.types.Field(Boolean, graphql_name="verifyCert")
    """Set to true to check the server certificate’s validity"""

    verify_identity = sgqlc.types.Field(Boolean, graphql_name="verifyIdentity")
    """Verify the server's identity"""

    skip_cert_verification = sgqlc.types.Field(Boolean, graphql_name="skipCertVerification")
    """Skip certificate verification"""


class StringFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "values")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")
    """Field name to filter on"""

    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="values"
    )
    """Values to filter by (combined via OR)"""


class TableMonitorAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("metric", "operator")
    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")

    operator = sgqlc.types.Field(String, graphql_name="operator")


class TableStatsRules(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("importance_score", "is_important")
    importance_score = sgqlc.types.Field(
        ImportanceScoreTableStatsRule, graphql_name="importanceScore"
    )

    is_important = sgqlc.types.Field(IsImportantTableStatsRule, graphql_name="isImportant")


class TableauConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "server_name",
        "username",
        "password",
        "client_id",
        "secret_id",
        "secret_value",
        "token_name",
        "token_value",
        "site_name",
        "verify_ssl",
    )
    server_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="serverName")
    """The Tableau server name"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """Username for the Tableau user if using username/password or
    Connected Apps
    """

    password = sgqlc.types.Field(String, graphql_name="password")
    """Password for the Tableau user if using username/password"""

    client_id = sgqlc.types.Field(String, graphql_name="clientId")
    """The Tableau Connected Apps Client ID"""

    secret_id = sgqlc.types.Field(String, graphql_name="secretId")
    """The Tableau Connected Apps Secret ID"""

    secret_value = sgqlc.types.Field(String, graphql_name="secretValue")
    """The Tableau Connected Apps Secret value"""

    token_name = sgqlc.types.Field(String, graphql_name="tokenName")
    """The personal access token name for PAT authentication"""

    token_value = sgqlc.types.Field(String, graphql_name="tokenValue")
    """The personal access token value for PAT authentication"""

    site_name = sgqlc.types.Field(String, graphql_name="siteName")
    """The Tableau site name"""

    verify_ssl = sgqlc.types.Field(Boolean, graphql_name="verifySsl")
    """Whether to verify the SSL connection to Tableau server"""


class TableauUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "server_name",
        "username",
        "password",
        "token_name",
        "token_value",
        "client_id",
        "secret_id",
        "secret_value",
        "site_name",
        "verify_ssl",
    )
    server_name = sgqlc.types.Field(String, graphql_name="serverName")
    """The Tableau server name"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """Username for the Tableau user if using username/password or
    Connected Apps
    """

    password = sgqlc.types.Field(String, graphql_name="password")
    """Password for the Tableau user if using username/password"""

    token_name = sgqlc.types.Field(String, graphql_name="tokenName")
    """The personal access token name for PAT authentication"""

    token_value = sgqlc.types.Field(String, graphql_name="tokenValue")
    """The personal access token value for PAT authentication"""

    client_id = sgqlc.types.Field(String, graphql_name="clientId")
    """The Tableau Connected Apps Client ID"""

    secret_id = sgqlc.types.Field(String, graphql_name="secretId")
    """The Tableau Connected Apps Secret ID"""

    secret_value = sgqlc.types.Field(String, graphql_name="secretValue")
    """The Tableau Connected Apps Secret value"""

    site_name = sgqlc.types.Field(String, graphql_name="siteName")
    """The Tableau site name"""

    verify_ssl = sgqlc.types.Field(Boolean, graphql_name="verifySsl")
    """Whether to verify the SSL connection to Tableau server"""


class TagFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("tag_name", "tag_values")
    tag_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tagName")
    """Tag name"""

    tag_values = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tagValues")
    """Tag values. If empty, match all with tag_name"""


class TagKeyValuePairInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Tag key"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Tag Value"""


class TagPair(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Tag key"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Tag Value"""


class TasksPerformanceFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("start_time", "end_time", "job_mcon")
    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")
    """Starting time of period to query for"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """Ending time of period to query for"""

    job_mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobMcon")
    """Job mcon to get associated tasks"""


class TasksPerformancePagingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("first", "after", "last", "before", "order_by", "order_direction")
    first = sgqlc.types.Field(Int, graphql_name="first")
    """Number of items to retrieve after the cursor. Defaults to 20 if no
    other paging parameters are provided
    """

    after = sgqlc.types.Field(String, graphql_name="after")
    """Starting cursor when paging forward"""

    last = sgqlc.types.Field(Int, graphql_name="last")
    """Number of items to retrieve before the cursor when paging backward"""

    before = sgqlc.types.Field(String, graphql_name="before")
    """Ending cursor when paging backward"""

    order_by = sgqlc.types.Field(TasksPerformanceSummarySort, graphql_name="orderBy")
    """Field by which to order the results. Defaults to
    LAST_RUN_START_TIME
    """

    order_direction = sgqlc.types.Field(EtlPerformanceSortDirection, graphql_name="orderDirection")
    """Sort direction. Defaults to EnumMeta.ASC"""


class ThresholdModifierInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("modifier_type", "value")
    modifier_type = sgqlc.types.Field(
        sgqlc.types.non_null(ThresholdModifierType), graphql_name="modifierType"
    )
    """The type of threshold modifier"""

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")
    """The value of the threshold modifier. If the type is PERCENTAGE,
    this should be a decimal value.
    """


class TimeRangeInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "metric_group_period_unit",
        "look_back_length",
        "look_back_unit",
        "start_time",
        "end_time",
    )
    metric_group_period_unit = sgqlc.types.Field(
        sgqlc.types.non_null(TimeRangeUnit), graphql_name="metricGroupPeriodUnit"
    )
    """Metric group unit. Will be used as the granularity for metrics on
    the Dashboard.
    """

    look_back_length = sgqlc.types.Field(Int, graphql_name="lookBackLength")
    """Look back length in integer. Together with look_back_unit, they
    defined how many days/weeks/months to look back by default. When
    this is set, look_back_unit should be set as well,
    start_time/end_time will be ignored.
    """

    look_back_unit = sgqlc.types.Field(TimeRangeUnit, graphql_name="lookBackUnit")
    """Look back time unit. Together with look_back_length, they define
    how many days/weeks/months to look back by default.When this is
    set, look_back_length is required, start_time/end_time will be
    ignored.
    """

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time for metrics on this dashboard. If this is set, the
    end_time is required. If look_back_length and/or look_back_unit is
    set, this field is ignored.
    """

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """End time for metrics on this dashboard. If this is set, the
    start_time is required. If look_back_length and/or look_back_unit
    is set, this field is ignored.
    """


class TimestampFilterInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "ranges")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")
    """Field name to filter on"""

    ranges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TimestampRangeInput")), graphql_name="ranges"
    )
    """Time ranges to filter by (combined via OR)"""


class TimestampHistogramSimpleWidgetConfig(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("additional_aggregate_metrics", "time_bucket_size")
    additional_aggregate_metrics = sgqlc.types.Field(
        sgqlc.types.list_of(AggregateMetricParams), graphql_name="additionalAggregateMetrics"
    )

    time_bucket_size = sgqlc.types.Field(TimeBucketSize, graphql_name="timeBucketSize")
    """Aggregation time bucket size"""


class TimestampRangeInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("start_time", "end_time")
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Time range start"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """Time range end"""


class TimestampResult(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("field_name", "timestamp")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")


class ToggleDatasetInputItem(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dw_id", "ds_id")
    dw_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dwId")
    """Warehouse the dataset is contained in."""

    ds_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dsId")
    """ID of the dataset."""


class ToggleMuteDatasetInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dw_id", "ds_id", "mute", "muted_event_types", "client_mutation_id")
    dw_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dwId")
    """Warehouse the dataset is contained in."""

    ds_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dsId")
    """ID of the dataset."""

    mute = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="mute")
    """True for muting the table, False for un-muting"""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Restrict muting to the following event types (optional)"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteDatasetsInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("datasets", "mute", "muted_event_types", "client_mutation_id")
    datasets = sgqlc.types.Field(
        sgqlc.types.list_of(ToggleDatasetInputItem), graphql_name="datasets"
    )
    """The datasets being muted"""

    mute = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="mute")
    """True for muting the table, False for un-muting"""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Restrict muting to the following event types (optional)"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteTableInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "full_table_id",
        "dw_id",
        "mute",
        "muted_event_types",
        "client_mutation_id",
    )
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Mcon of table to toggle muting for"""

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")
    """Deprecated - use mcon. Ignored if mcon is present"""

    dw_id = sgqlc.types.Field(UUID, graphql_name="dwId")
    """Warehouse the table is contained in. Required when using a
    fullTableId
    """

    mute = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="mute")
    """True for muting the table, False for un-muting"""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Restrict muting to the following event types (optional)"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteTablesInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("tables", "mute", "muted_event_types", "client_mutation_id")
    tables = sgqlc.types.Field(sgqlc.types.list_of("ToggleTableInputItem"), graphql_name="tables")
    """The tables being muted"""

    mute = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="mute")
    """True for muting the table, False for un-muting"""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Restrict muting to the following event types (optional)"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteWithRegexInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("dw_id", "rule_regex", "mute", "muted_event_types", "client_mutation_id")
    dw_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dwId")
    """Warehouse the dataset is contained in."""

    rule_regex = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ruleRegex")
    """Valid regex to match fullTableIds. FullTableIds have the following
    format: "PROJECT_NAME:DATASET_NAME.TABLE_ID"
    """

    mute = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="mute")
    """True for muting the table, False for un-muting"""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Restrict muting to the following event types (optional)"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleTableInputItem(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("mcon", "full_table_id", "dw_id")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Mcon of the table to toggle muting for"""

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")
    """Deprecated - use mcon. Ignored if mcon is present"""

    dw_id = sgqlc.types.Field(UUID, graphql_name="dwId")
    """Warehouse the table is contained in. Required when using a full
    table id
    """


class TopQueryGroupsRequestType(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("search_criteria", "first", "offset", "sort_field", "metric_field_name")
    search_criteria = sgqlc.types.Field(
        sgqlc.types.non_null(SearchCriteriaType), graphql_name="searchCriteria"
    )

    first = sgqlc.types.Field(Int, graphql_name="first")

    offset = sgqlc.types.Field(Int, graphql_name="offset")

    sort_field = sgqlc.types.Field(String, graphql_name="sortField")

    metric_field_name = sgqlc.types.Field(String, graphql_name="metricFieldName")


class TraceFilterDataRequest(sgqlc.types.Input):
    """Request for filter values data."""

    __schema__ = schema
    __field_names__ = ("field_name", "search_criteria", "first", "after", "search_value")
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(TraceFilterFieldName), graphql_name="fieldName"
    )
    """Filter field name to get values for"""

    search_criteria = sgqlc.types.Field(
        sgqlc.types.non_null("TraceFilterDataSearchCriteria"), graphql_name="searchCriteria"
    )
    """Search criteria"""

    first = sgqlc.types.Field(Int, graphql_name="first")
    """Number of values to return (max 50)"""

    after = sgqlc.types.Field(String, graphql_name="after")
    """Cursor for pagination"""

    search_value = sgqlc.types.Field(String, graphql_name="searchValue")
    """Search string to filter values"""


class TraceFilterDataSearchCriteria(sgqlc.types.Input):
    """Search criteria for getting filter values."""

    __schema__ = schema
    __field_names__ = ("agent_name", "trace_table_mcon", "start_time", "end_time", "filters")
    agent_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="agentName")
    """Agent name"""

    trace_table_mcon = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="traceTableMcon"
    )
    """Trace table MCON"""

    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")
    """Start time for traces"""

    end_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="endTime")
    """End time for traces"""

    filters = sgqlc.types.Field(
        sgqlc.types.list_of("TraceFilterDataSearchCriteriaFilter"), graphql_name="filters"
    )
    """Active filters to apply (for cross-filtering)"""


class TraceFilterDataSearchCriteriaFilter(sgqlc.types.Input):
    """A filter to apply when getting filter values (for cross-
    filtering).
    """

    __schema__ = schema
    __field_names__ = ("field_name", "value")
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(TraceFilterFieldName), graphql_name="fieldName"
    )
    """Filter field name"""

    value = sgqlc.types.Field(GenericScalar, graphql_name="value")
    """Filter value"""


class TraceFiltersInput(sgqlc.types.Input):
    """Optional filters to refine trace results within the time range."""

    __schema__ = schema
    __field_names__ = (
        "models",
        "workflows",
        "tasks",
        "min_duration",
        "max_duration",
        "min_prompt_tokens",
        "max_prompt_tokens",
        "min_completion_tokens",
        "max_completion_tokens",
        "min_total_tokens",
        "max_total_tokens",
    )
    models = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="models"
    )
    """Filter by model names (OR logic)"""

    workflows = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="workflows"
    )
    """Filter by workflow names (OR logic)"""

    tasks = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tasks"
    )
    """Filter by task names (OR logic)"""

    min_duration = sgqlc.types.Field(Float, graphql_name="minDuration")
    """Minimum duration in seconds"""

    max_duration = sgqlc.types.Field(Float, graphql_name="maxDuration")
    """Maximum duration in seconds"""

    min_prompt_tokens = sgqlc.types.Field(Int, graphql_name="minPromptTokens")
    """Minimum prompt tokens"""

    max_prompt_tokens = sgqlc.types.Field(Int, graphql_name="maxPromptTokens")
    """Maximum prompt tokens"""

    min_completion_tokens = sgqlc.types.Field(Int, graphql_name="minCompletionTokens")
    """Minimum completion tokens"""

    max_completion_tokens = sgqlc.types.Field(Int, graphql_name="maxCompletionTokens")
    """Maximum completion tokens"""

    min_total_tokens = sgqlc.types.Field(Int, graphql_name="minTotalTokens")
    """Minimum total tokens"""

    max_total_tokens = sgqlc.types.Field(Int, graphql_name="maxTotalTokens")
    """Maximum total tokens"""


class TrackTableInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("mcon", "full_table_id", "dw_id", "track", "client_mutation_id")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Mcon of table to toggle tracking for"""

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")
    """Deprecated - use mcon. Ignored if mcon is present"""

    dw_id = sgqlc.types.Field(UUID, graphql_name="dwId")
    """Warehouse the table is contained in. Required when using a
    fullTableId
    """

    track = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="track")
    """Enable or disable table tracking"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class TransactionalDbConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "db_name",
        "db_type",
        "host",
        "port",
        "user",
        "password",
        "token",
        "consumer_key",
        "consumer_secret",
        "connection_settings",
        "domain",
    )
    db_name = sgqlc.types.Field(String, graphql_name="dbName")
    """Name of database to add connection for"""

    db_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dbType")
    """Type of Transactional DB to add connection for"""

    host = sgqlc.types.Field(String, graphql_name="host")
    """Hostname of the warehouse"""

    port = sgqlc.types.Field(Int, graphql_name="port")
    """HTTP Port to use"""

    user = sgqlc.types.Field(String, graphql_name="user")
    """User with access to the database"""

    password = sgqlc.types.Field(String, graphql_name="password")
    """User's password"""

    token = sgqlc.types.Field(String, graphql_name="token")
    """Auth Token for connection"""

    consumer_key = sgqlc.types.Field(String, graphql_name="consumerKey")
    """Consumer key for connection"""

    consumer_secret = sgqlc.types.Field(String, graphql_name="consumerSecret")
    """Consumer secret for connection"""

    connection_settings = sgqlc.types.Field(
        "TransactionalDbConnectionSettings", graphql_name="connectionSettings"
    )
    """Optional connection settings"""

    domain = sgqlc.types.Field(String, graphql_name="domain")
    """Domain for the connection"""


class TransactionalDbConnectionSettings(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("td_sslmode", "td_logmech", "tls", "ssl_options", "rds_proxy")
    td_sslmode = sgqlc.types.Field(TeradataSSLModeEnum, graphql_name="tdSslmode")
    """Specifies the mode for connections to Teradata database."""

    td_logmech = sgqlc.types.Field(TeradataLogMechEnum, graphql_name="tdLogmech")
    """Teradata logon authentication method."""

    tls = sgqlc.types.Field(Boolean, graphql_name="tls")
    """Should we use TLS when connecting to Dremio, required for Dremio
    Cloud.
    """

    ssl_options = sgqlc.types.Field(SslOptions, graphql_name="sslOptions")
    """Optional SSL options."""

    rds_proxy = sgqlc.types.Field(Boolean, graphql_name="rdsProxy")
    """Indicates if we are connecting to the database through a RDS
    Proxy.
    """


class TransactionalDbUpdateConnectionDetails(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "db_name",
        "db_type",
        "host",
        "port",
        "user",
        "password",
        "token",
        "consumer_key",
        "consumer_secret",
        "domain",
        "connection_settings",
        "ssl_options",
    )
    db_name = sgqlc.types.Field(String, graphql_name="dbName")
    """Name of database to add connection for"""

    db_type = sgqlc.types.Field(String, graphql_name="dbType")
    """Type of Transactional DB to add connection for"""

    host = sgqlc.types.Field(String, graphql_name="host")
    """Hostname of the warehouse"""

    port = sgqlc.types.Field(Int, graphql_name="port")
    """HTTP Port to use"""

    user = sgqlc.types.Field(String, graphql_name="user")
    """User with access to the database"""

    password = sgqlc.types.Field(String, graphql_name="password")
    """User's password"""

    token = sgqlc.types.Field(String, graphql_name="token")
    """Token to access the database"""

    consumer_key = sgqlc.types.Field(String, graphql_name="consumerKey")
    """OAuth client ID or consumer key"""

    consumer_secret = sgqlc.types.Field(String, graphql_name="consumerSecret")
    """OAuth client secret or consumer secret"""

    domain = sgqlc.types.Field(String, graphql_name="domain")
    """Domain to use for the connection"""

    connection_settings = sgqlc.types.Field(
        "TransactionalDbUpdateConnectionSettings", graphql_name="connectionSettings"
    )
    """Optional connection settings"""

    ssl_options = sgqlc.types.Field(SslUpdateOptions, graphql_name="sslOptions")
    """Optional SSL options."""


class TransactionalDbUpdateConnectionSettings(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("td_sslmode", "td_logmech", "rds_proxy")
    td_sslmode = sgqlc.types.Field(TeradataSSLModeUpdateEnum, graphql_name="tdSslmode")
    """Specifies the mode for connections to Teradata database."""

    td_logmech = sgqlc.types.Field(TeradataLogMechUpdateEnum, graphql_name="tdLogmech")
    """Teradata logon authentication method."""

    rds_proxy = sgqlc.types.Field(Boolean, graphql_name="rdsProxy")
    """Indicates if we are connecting to the database through a RDS
    Proxy.
    """


class TransformInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "alias",
        "prompt",
        "categories",
        "model_connection_id",
        "output_type",
        "sql_expression",
        "field_config_list",
        "model_name",
        "function",
        "field",
        "id",
    )
    alias = sgqlc.types.Field(String, graphql_name="alias")

    prompt = sgqlc.types.Field(String, graphql_name="prompt")

    categories = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ClassificationCategoriesInput)),
        graphql_name="categories",
    )

    model_connection_id = sgqlc.types.Field(String, graphql_name="modelConnectionId")

    output_type = sgqlc.types.Field(String, graphql_name="outputType")

    sql_expression = sgqlc.types.Field(String, graphql_name="sqlExpression")

    field_config_list = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(FieldConfigInput)), graphql_name="fieldConfigList"
    )

    model_name = sgqlc.types.Field(String, graphql_name="modelName")

    function = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="function")

    field = sgqlc.types.Field(String, graphql_name="field")

    id = sgqlc.types.Field(String, graphql_name="id")


class UCSAutomatedAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("sensitivity_level",)
    sensitivity_level = sgqlc.types.Field(
        sgqlc.types.non_null(SensitivityLevels), graphql_name="sensitivityLevel"
    )
    """Sensitivity for automated thresholds"""


class UCSExplicitAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "start_time",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "timezone",
        "is_auto_schedule_config",
        "threshold",
    )
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of the collection"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Collection interval in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Collection interval in crontab format"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions"""

    is_auto_schedule_config = sgqlc.types.Field(Boolean, graphql_name="isAutoScheduleConfig")
    """Set to true to use auto schedule configuration"""

    threshold = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="threshold")
    """Explicit freshness threshold in minutes"""


class UpdateDataShareInput(sgqlc.types.Input):
    """Input for updating Snowflake data share configuration"""

    __schema__ = schema
    __field_names__ = ("enabled", "account_id", "account_name", "data_share")
    enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="enabled")
    """Whether to enable data sharing"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """UUID of the account to update"""

    account_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accountName")
    """Name of the account (validation)"""

    data_share = sgqlc.types.Field(DataShareInput, graphql_name="dataShare")
    """Input data share attributes"""


class UpdateUserStateInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("state", "client_mutation_id")
    state = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="state")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class UsageAlertConfigInput(sgqlc.types.Input):
    """input variables for daily usage alert"""

    __schema__ = schema
    __field_names__ = ("threshold", "emails", "disabled")
    threshold = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="threshold")
    """Usage threshold that triggers the alert"""

    emails = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="emails"
    )
    """List of recipients"""

    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Disable the alert (optional)"""


class UserSettingInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("key", "value", "description")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """User setting key"""

    value = sgqlc.types.Field(JSONString, graphql_name="value")
    """User settings"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description for this user's settings"""


class ValidatorTestOptions(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "validate_select",
        "validate_info_access",
        "validate_table_metadata",
        "validate_syslog",
    )
    validate_select = sgqlc.types.Field(Boolean, graphql_name="validateSelect")
    """Whether the validate select query should be executed"""

    validate_info_access = sgqlc.types.Field(Boolean, graphql_name="validateInfoAccess")
    """Whether the validate info access query should be executed"""

    validate_table_metadata = sgqlc.types.Field(Boolean, graphql_name="validateTableMetadata")
    """Whether the validate table metadata query should be executed"""

    validate_syslog = sgqlc.types.Field(Boolean, graphql_name="validateSyslog")
    """Whether the validate syslog query should be executed"""


class VariableDefinitionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("name", "runtime", "values")
    name = sgqlc.types.Field(String, graphql_name="name")

    runtime = sgqlc.types.Field(Boolean, graphql_name="runtime")

    values = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="values"
    )


class VolumeChangeAutomatedAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("sensitivity_level",)
    sensitivity_level = sgqlc.types.Field(
        sgqlc.types.non_null(SensitivityLevels), graphql_name="sensitivityLevel"
    )
    """Sensitivity for automated thresholds"""


class VolumeChangeExplicitAlertConditionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = (
        "start_time",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "timezone",
        "threshold_lookback_minutes",
        "upper_threshold",
        "lower_threshold",
    )
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of the collection"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Collection interval in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Collection interval in crontab format"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions"""

    threshold_lookback_minutes = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="thresholdLookbackMinutes"
    )
    """Threshold lookback in minutes"""

    upper_threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="upperThreshold")
    """Upper threshold in percent"""

    lower_threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="lowerThreshold")
    """Lower threshold in percent"""


class WebhookHeaderInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """The header field name"""

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """The header field value"""


class WidgetConfig(sgqlc.types.Input):
    """Widget configuration.             Only one (or none)
    of these properties should be set, depending on the widget type.
    For widgetType=TIMESTAMP_HISTOGRAM, use timestampHistogramConfig.
    For widgetType=NUMERICAL_CONTINUOUS, use
    numericalContinuousConfig.
    """

    __schema__ = schema
    __field_names__ = ("timestamp_histogram_config",)
    timestamp_histogram_config = sgqlc.types.Field(
        TimestampHistogramSimpleWidgetConfig, graphql_name="timestampHistogramConfig"
    )


class WidgetDataSourceUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("time_series_id", "monitor_id", "data_source_id", "type")
    time_series_id = sgqlc.types.Field(UUID, graphql_name="timeSeriesId")

    monitor_id = sgqlc.types.Field(UUID, graphql_name="monitorId")

    data_source_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dataSourceId")

    type = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardWidgetDataSourceType), graphql_name="type"
    )


class WidgetOptionsUnionInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("content", "field", "show_thresholds", "fields", "type")
    content = sgqlc.types.Field(String, graphql_name="content")

    field = sgqlc.types.Field(String, graphql_name="field")

    show_thresholds = sgqlc.types.Field(Boolean, graphql_name="showThresholds")

    fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fields"
    )

    type = sgqlc.types.Field(sgqlc.types.non_null(CustomDashboardWidgetType), graphql_name="type")


class WildcardTemplateInput(sgqlc.types.Input):
    __schema__ = schema
    __field_names__ = ("template_name", "template_regex")
    template_name = sgqlc.types.Field(String, graphql_name="templateName")

    template_regex = sgqlc.types.Field(String, graphql_name="templateRegex")


########################################################################
# Output Objects and Interfaces
########################################################################
class AssetCollectionPreferenceNode(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("id",)
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")
    """The ID of the object."""


class AssetFilterInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type", "negated")
    type = sgqlc.types.Field(sgqlc.types.non_null(AssetFilterType), graphql_name="type")

    negated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="negated")


class CollectionPreferenceNode(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("id",)
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")
    """The ID of the object."""


class DataSourceInputInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type", "connection_type", "schema")
    type = sgqlc.types.Field(sgqlc.types.non_null(DataSourceType), graphql_name="type")

    connection_type = sgqlc.types.Field(String, graphql_name="connectionType")

    schema = sgqlc.types.Field("DataSourceSchema", graphql_name="schema")


class DataSourceInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type", "connection_type", "schema")
    type = sgqlc.types.Field(sgqlc.types.non_null(DataSourceType), graphql_name="type")

    connection_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="connectionType")

    schema = sgqlc.types.Field(sgqlc.types.non_null("DataSourceSchema"), graphql_name="schema")


class FilterInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type", "id")
    type = sgqlc.types.Field(sgqlc.types.non_null(FilterType), graphql_name="type")

    id = sgqlc.types.Field(String, graphql_name="id")


class FilterValueInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type", "id")
    type = sgqlc.types.Field(sgqlc.types.non_null(FilterValueType), graphql_name="type")

    id = sgqlc.types.Field(String, graphql_name="id")


class IBaseRca(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("rca_type", "rca_uuid")
    rca_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="rcaType")
    """RCA type"""

    rca_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="rcaUuid")
    """Unique identifier of an RCA"""


class IComparisonMonitor(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("source", "target")
    source = sgqlc.types.Field("ExtendedDataSource", graphql_name="source")

    target = sgqlc.types.Field("ExtendedDataSource", graphql_name="target")


class ICustomRulesMonitor(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "has_custom_rule_name",
        "rule_description",
        "rule_comparisons",
        "rule_notes",
        "rule_variables",
        "variable_definitions",
        "is_snoozed",
        "snooze_until_time",
        "slack_snooze_user",
        "conditional_snooze",
        "breach_rate",
        "comments_count",
        "interval_minutes",
        "custom_sql_rule_type",
        "invalid_rows",
        "alert_ids",
        "breached",
        "migrated_to_uuid",
    )
    has_custom_rule_name = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasCustomRuleName"
    )
    """Whether the monitor has a name given by the monitor creator"""

    rule_description = sgqlc.types.Field(String, graphql_name="ruleDescription")
    """**DEPRECATED**"""

    rule_comparisons = sgqlc.types.Field(
        sgqlc.types.list_of("CustomRuleComparison"), graphql_name="ruleComparisons"
    )
    """Deprecated in favor of comparisons"""

    rule_notes = sgqlc.types.Field(String, graphql_name="ruleNotes")
    """**DEPRECATED**"""

    rule_variables = sgqlc.types.Field(JSONString, graphql_name="ruleVariables")
    """variables defined for the sql rule"""

    variable_definitions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("VariableDefinition")),
        graphql_name="variableDefinitions",
    )
    """Possible variable values for SQL query. Allows specifying runtime
    variables as well.
    """

    is_snoozed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSnoozed")
    """Whether the monitor is currently snoozed"""

    snooze_until_time = sgqlc.types.Field(DateTime, graphql_name="snoozeUntilTime")
    """If snoozed, the wake up time in UTC"""

    slack_snooze_user = sgqlc.types.Field(String, graphql_name="slackSnoozeUser")
    """Slack user who snoozed rule"""

    conditional_snooze = sgqlc.types.Field(Boolean, graphql_name="conditionalSnooze")
    """Whether the monitor is conditionally snoozed"""

    breach_rate = sgqlc.types.Field(String, graphql_name="breachRate")
    """Percentage of last 10 runs in which the monitor's condition was
    breached
    """

    comments_count = sgqlc.types.Field(Int, graphql_name="commentsCount")
    """Number of comments on this monitor"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Interval between monitor runs, in minutes"""

    custom_sql_rule_type = sgqlc.types.Field(String, graphql_name="customSqlRuleType")
    """The type of custom SQL rule. Only set for custom SQL rules"""

    invalid_rows = sgqlc.types.Field(BigInt, graphql_name="invalidRows")
    """Number of invalid rows. Only for alerted monitors"""

    alert_ids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="alertIds")
    """Alert ids related last breached run. Is only returned if monitor
    is breached.
    """

    breached = sgqlc.types.Field(MonitorBreachType, graphql_name="breached")
    """Monitor breached status"""

    migrated_to_uuid = sgqlc.types.Field(String, graphql_name="migratedToUuid")
    """UUID of the monitor this was migrated to, if applicable"""


class IEtlAssetPerformanceSummary(sgqlc.types.Interface):
    """ETL asset performance summary (such as a job or a task)"""

    __schema__ = schema
    __field_names__ = (
        "mcon",
        "display_name",
        "integration_type",
        "run_count",
        "last_run_uuid",
        "last_run_start_time",
        "last_run_end_time",
        "last_run_status",
        "avg_run_duration",
        "run_duration_trend7d",
        "run_duration_trend7d_issue",
        "failure_rate",
        "runs",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Unique MC identifier for the asset"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Human-readable name of the asset"""

    integration_type = sgqlc.types.Field(
        sgqlc.types.non_null(EtlType), graphql_name="integrationType"
    )
    """The integration type of the asset"""

    run_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="runCount")
    """Total runs for the asset, in the period"""

    last_run_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="lastRunUuid")
    """Last run of the asset, in the period"""

    last_run_start_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="lastRunStartTime"
    )
    """The start time of the last run of the asset, in the period"""

    last_run_end_time = sgqlc.types.Field(DateTime, graphql_name="lastRunEndTime")
    """The end time of the last run of the asset, in the period"""

    last_run_status = sgqlc.types.Field(
        sgqlc.types.non_null(EtlRunStatus), graphql_name="lastRunStatus"
    )
    """The status of the last run of the asset, in the period."""

    avg_run_duration = sgqlc.types.Field(Int, graphql_name="avgRunDuration")
    """Average duration of runs for the asset in the period, in ms"""

    run_duration_trend7d = sgqlc.types.Field(Float, graphql_name="runDurationTrend7d")
    """7-day trend of successful run durations for the asset, expressed
    as a decimal percentage (e.g., 0.15 = 15% increase). null if it
    cannot be calculated — see runDurationTrend7dIssue for details
    """

    run_duration_trend7d_issue = sgqlc.types.Field(
        EtlDurationTrendIssue, graphql_name="runDurationTrend7dIssue"
    )
    """If the 7-day trend cannot be calculated, this provides the reason
    why
    """

    failure_rate = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="failureRate")
    """Failure rate, expressed as a decimal percentage (.50 = 50%)"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(sgqlc.types.list_of(String)))
        ),
        graphql_name="runs",
    )
    """List of run datapoints during the period for the asset, returned
    as a list of [start time (epoch ms), duration (ms), status]. For
    failures, it also includes [failure time (epoch ms)]
    """


class IEventDataBaseTimeline(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "updated_by_email",
        "updated_by_name",
        "updated_by_cognito_id",
        "updated_by_id",
        "updated_at",
        "event_uuid",
    )
    updated_by_email = sgqlc.types.Field(String, graphql_name="updatedByEmail")
    """email of the person who did some update that lead to this timeline
    item
    """

    updated_by_name = sgqlc.types.Field(String, graphql_name="updatedByName")
    """ame of the person who did some update that lead to this timeline
    item
    """

    updated_by_cognito_id = sgqlc.types.Field(String, graphql_name="updatedByCognitoId")
    """cognito id of the person who did some update that lead to this
    timeline item
    """

    updated_by_id = sgqlc.types.Field(String, graphql_name="updatedById")
    """mc id of the person who did some update that lead to this timeline
    item
    """

    updated_at = sgqlc.types.Field(String, graphql_name="updatedAt")
    """formatted datetime of when the timeline created"""

    event_uuid = sgqlc.types.Field(UUID, graphql_name="eventUuid")
    """Event unique identifier"""


class IMetricsMonitor(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "monitor_fields",
        "monitor_time_axis_field_name",
        "monitor_time_axis_field_type",
        "where_condition",
        "use_partition_clause",
        "segmented_expressions",
        "segmentation_type",
        "history_days",
        "collection_lag_hours",
        "select_expressions",
        "selected_metrics",
        "agg_time_interval",
        "high_segment_count",
        "min_segment_size",
        "segment_count",
        "bootstrap",
        "sensitivity",
        "monitor_sql_blocks",
        "agent_span_filters",
        "sampling_config",
        "filters",
    )
    monitor_fields = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="monitorFields")
    """Field/s to monitor"""

    monitor_time_axis_field_name = sgqlc.types.Field(
        String, graphql_name="monitorTimeAxisFieldName"
    )
    """The name of the table/view field used for establishing the table
    time
    """

    monitor_time_axis_field_type = sgqlc.types.Field(
        String, graphql_name="monitorTimeAxisFieldType"
    )
    """Type of time axis field used for establishing the table time"""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """Comparison predicate for the monitor SQL query"""

    use_partition_clause = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usePartitionClause"
    )
    """Whether to use automatic partition filter in query"""

    segmented_expressions = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="segmentedExpressions"
    )
    """Fields or expressions used to segment the monitored field
    (currently supports one such value)
    """

    segmentation_type = sgqlc.types.Field(SegmentationType, graphql_name="segmentationType")
    """The type of segmentation specified in segmented_expressions. For
    instance field or custom_sql_expression.
    """

    history_days = sgqlc.types.Field(Int, graphql_name="historyDays")
    """Number of lookback days for each monitor execution"""

    collection_lag_hours = sgqlc.types.Field(Int, graphql_name="collectionLagHours")
    """Hours to delay data collection. Only available for metric monitors
    with version >= 2.
    """

    select_expressions = sgqlc.types.Field(
        sgqlc.types.list_of("MetricMonitorSelectExpression"), graphql_name="selectExpressions"
    )
    """Monitor select expression"""

    selected_metrics = sgqlc.types.Field(
        sgqlc.types.list_of(FieldHealthMetrics), graphql_name="selectedMetrics"
    )
    """Selected metrics for the monitor. If empty, all metrics will be
    monitored. Only available for Field Health monitors.
    """

    agg_time_interval = sgqlc.types.Field(MonitorAggTimeInterval, graphql_name="aggTimeInterval")
    """For field health and dimension monitoring, the aggregation time
    interval to use. Either HOUR or DAY
    """

    high_segment_count = sgqlc.types.Field(Boolean, graphql_name="highSegmentCount")
    """Flag to apply additional limits which increase the supported
    segment count
    """

    min_segment_size = sgqlc.types.Field(Int, graphql_name="minSegmentSize")
    """Minimum number of rows for a segment to be retrieved. Segments
    with less rows than this will be discarded.
    """

    segment_count = sgqlc.types.Field(Int, graphql_name="segmentCount")
    """Number of segments collected on the last run of the monitor, or
    hinted during creation. If the monitor wasn't able to run, or the
    the monitor wasjust created and no segment count was passed during
    creation, the value will be null.
    """

    bootstrap = sgqlc.types.Field("MonitorBootstrap", graphql_name="bootstrap")
    """Current bootstrap state of the monitor"""

    sensitivity = sgqlc.types.Field(SensitivityLevels, graphql_name="sensitivity")
    """Sensitivity for automated thresholds"""

    monitor_sql_blocks = sgqlc.types.Field("MonitorSqlBlocks", graphql_name="monitorSqlBlocks")
    """SQL blocks used on the monitor"""

    agent_span_filters = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("AgentSpanFilter")),
        graphql_name="agentSpanFilters",
    )
    """agent span filters used on the monitor"""

    sampling_config = sgqlc.types.Field("MonitorSamplingConfig", graphql_name="samplingConfig")
    """Sampling configuration for the monitor"""

    filters = sgqlc.types.Field("FilterGroup", graphql_name="filters")
    """Filters used on the monitor"""


class IMonitor(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "monitor_type",
        "created_time",
        "last_update_time",
        "creator_id",
        "updater_id",
        "creator",
        "updater",
        "resource_id",
        "entities",
        "entity_mcons",
        "entity_count",
        "schedule_type",
        "name",
        "rule_name",
        "description",
        "notes",
        "labels",
        "failure_audiences",
        "severity",
        "priority",
        "comparisons",
        "data_source",
        "notification_settings",
        "notify_rule_run_failure",
        "is_snoozeable",
        "is_paused",
        "is_draft",
        "migrated_to_uuid",
        "is_template_managed",
        "namespace",
        "next_execution_time",
        "prev_execution_time",
        "is_transitioning_data_provider",
        "schedule_config",
        "thirty_days_incident_count",
        "seven_days_incident_count",
        "incident_count_history",
        "weekly_incident_count_change_rate",
        "seven_days_error_count",
        "thirty_days_error_history",
        "seven_days_timeout_count",
        "thirty_days_timeout_history",
        "connection_id",
        "version",
        "is_ootb_monitor",
        "ootb_monitor_type",
        "is_auto_threshold_available",
        "tags",
        "data_quality_dimension",
        "domain_uuids",
        "is_ootb_replacement",
        "timeout",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique identifier for monitors"""

    monitor_type = sgqlc.types.Field(
        sgqlc.types.non_null(UserDefinedMonitors), graphql_name="monitorType"
    )
    """Type of monitor"""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """Monitor creation time (UTC)"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """Monitor last update time (UTC)"""

    creator_id = sgqlc.types.Field(String, graphql_name="creatorId")
    """Email of user who created the monitor"""

    updater_id = sgqlc.types.Field(String, graphql_name="updaterId")
    """Email of user who last updated the monitor"""

    creator = sgqlc.types.Field("User", graphql_name="creator")
    """Monitor creator"""

    updater = sgqlc.types.Field("User", graphql_name="updater")
    """Monitor updater"""

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Warehouse Unique Identifier"""

    entities = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="entities")
    """Full table IDs for monitored tables/views"""

    entity_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="entityMcons")
    """MCONs for monitored tables/views"""

    entity_count = sgqlc.types.Field(Int, graphql_name="entityCount")
    """Number of monitored entities"""

    schedule_type = sgqlc.types.Field(String, graphql_name="scheduleType")
    """Monitor scheduling type"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Monitor/rule name, default or user-defined"""

    rule_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ruleName")
    """DEPRECATED: Rule name, default or user-defined, null for monitors.
    Use name instead.
    """

    description = sgqlc.types.Field(String, graphql_name="description")
    """Monitor user-defined name"""

    notes = sgqlc.types.Field(String, graphql_name="notes")
    """Notes defined on this monitor"""

    labels = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="labels")
    """List of tags used to filter a monitor"""

    failure_audiences = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="failureAudiences"
    )
    """List of audiences to notify on run failure"""

    severity = sgqlc.types.Field(String, graphql_name="severity")
    """DEPRECATED. Use priority instead. Default severity for incidents
    involving this monitor
    """

    priority = sgqlc.types.Field(String, graphql_name="priority")
    """Default priority for alerts involving this monitor"""

    comparisons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomRuleComparison")),
        graphql_name="comparisons",
    )
    """Metric evaluator configuration"""

    data_source = sgqlc.types.Field("MonitorDataSource", graphql_name="dataSource")
    """Data source for the monitor"""

    notification_settings = sgqlc.types.Field(
        sgqlc.types.list_of("AccountNotificationSetting"), graphql_name="notificationSettings"
    )
    """Notification channels that match the monitor. Only returned for
    custom monitors.
    """

    notify_rule_run_failure = sgqlc.types.Field(Boolean, graphql_name="notifyRuleRunFailure")
    """DEPRECATED: Completely ignored. This field has no effect on
    anything. Use `failure_audiences` to determine who is notified
    when run failures occur.
    """

    is_snoozeable = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSnoozeable")
    """Whether the monitor can be snoozed"""

    is_paused = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPaused")
    """Whether the monitor is currently paused"""

    is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft")
    """Whether the monitor is a draft"""

    migrated_to_uuid = sgqlc.types.Field(String, graphql_name="migratedToUuid")
    """UUID of the monitor this was migrated to, if applicable"""

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )
    """Whether the monitor was created from through monitor-as-code"""

    namespace = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="namespace")
    """The monitor-as-code namespace used when creating the monitor"""

    next_execution_time = sgqlc.types.Field(DateTime, graphql_name="nextExecutionTime")
    """The next time (UTC) in which the monitor will run"""

    prev_execution_time = sgqlc.types.Field(DateTime, graphql_name="prevExecutionTime")
    """The last time (UTC) in which the monitor ran"""

    is_transitioning_data_provider = sgqlc.types.Field(
        Boolean, graphql_name="isTransitioningDataProvider"
    )

    schedule_config = sgqlc.types.Field("ScheduleConfigOutput", graphql_name="scheduleConfig")

    thirty_days_incident_count = sgqlc.types.Field(Int, graphql_name="thirtyDaysIncidentCount")
    """Number of incidents in the past 30 days"""

    seven_days_incident_count = sgqlc.types.Field(Int, graphql_name="sevenDaysIncidentCount")
    """Number of incidents in the past 7 days"""

    incident_count_history = sgqlc.types.Field(
        sgqlc.types.list_of("IncidentDailyCount"), graphql_name="incidentCountHistory"
    )
    """Number of incidents per day for the past 30 days"""

    weekly_incident_count_change_rate = sgqlc.types.Field(
        Int, graphql_name="weeklyIncidentCountChangeRate"
    )
    """Change in percentage between between last 7 days and the 7 days
    before.
    """

    seven_days_error_count = sgqlc.types.Field(Int, graphql_name="sevenDaysErrorCount")
    """Number of failed runs in the past 7 days"""

    thirty_days_error_history = sgqlc.types.Field(
        sgqlc.types.list_of("RunDailyCount"), graphql_name="thirtyDaysErrorHistory"
    )
    """Number of failed runs per day for the past 30 days"""

    seven_days_timeout_count = sgqlc.types.Field(Int, graphql_name="sevenDaysTimeoutCount")
    """Number of timeout runs in the past 7 days"""

    thirty_days_timeout_history = sgqlc.types.Field(
        sgqlc.types.list_of("RunDailyCount"), graphql_name="thirtyDaysTimeoutHistory"
    )
    """Number of timeout runs per day for the past 30 days"""

    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """The connection UUID associated with the rule"""

    version = sgqlc.types.Field(String, graphql_name="version")
    """Indicates the version of this monitor. For instance, older
    freshness and volume rules will have version '1' and unified new
    ones will have version '2'.
    """

    is_ootb_monitor = sgqlc.types.Field(Boolean, graphql_name="isOotbMonitor")
    """Indicates whether this is an OOTB monitor (set to true for OOTB
    monitors and OOTB replacement rules)
    """

    ootb_monitor_type = sgqlc.types.Field(OotbTableMonitorTypeEnum, graphql_name="ootbMonitorType")
    """The type of OOTB monitor"""

    is_auto_threshold_available = sgqlc.types.Field(
        Boolean, graphql_name="isAutoThresholdAvailable"
    )
    """For OOTB monitors, this flag indicates whether ML thresholds are
    available.
    """

    tags = sgqlc.types.Field(sgqlc.types.list_of("TagKeyValuePairOutput"), graphql_name="tags")
    """Tags on this monitor."""

    data_quality_dimension = sgqlc.types.Field(String, graphql_name="dataQualityDimension")
    """Data quality dimension on a monitor."""

    domain_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainUuids"
    )
    """Domain UUIDs assigned to the monitor."""

    is_ootb_replacement = sgqlc.types.Field(Boolean, graphql_name="isOotbReplacement")
    """(experimental) Returns if this monitor replaces the default ootb
    detector.
    """

    timeout = sgqlc.types.Field(Int, graphql_name="timeout")
    """Timeout for the SQL query"""


class IMonitorStatus(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "monitor_run_status",
        "monitor_configuration_status",
        "monitor_training_status",
        "monitor_status",
        "consolidated_monitor_status",
        "exceptions",
    )
    monitor_run_status = sgqlc.types.Field(
        sgqlc.types.non_null(MonitorRunStatusType), graphql_name="monitorRunStatus"
    )
    """Monitor run status"""

    monitor_configuration_status = sgqlc.types.Field(
        sgqlc.types.non_null(MonitorConfigurationStatusType),
        graphql_name="monitorConfigurationStatus",
    )
    """Monitor configuration status"""

    monitor_training_status = sgqlc.types.Field(
        sgqlc.types.non_null(MonitorTrainingStatusType), graphql_name="monitorTrainingStatus"
    )
    """Monitor training status"""

    monitor_status = sgqlc.types.Field(
        sgqlc.types.non_null(MonitorStatusType), graphql_name="monitorStatus"
    )
    """Consolidated monitor status"""

    consolidated_monitor_status = sgqlc.types.Field(
        sgqlc.types.non_null(ConsolidatedMonitorStatusType),
        graphql_name="consolidatedMonitorStatus",
    )
    """Consolidated monitor status that indicates the overall status of
    the monitor
    """

    exceptions = sgqlc.types.Field(String, graphql_name="exceptions")
    """Exceptions if any occurred during the last run"""


class IQueryRca(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "query_log_group_hash",
        "query_log_id",
        "query_type",
        "query_subtype",
        "user",
        "start_time",
        "mcon",
    )
    query_log_group_hash = sgqlc.types.Field(String, graphql_name="queryLogGroupHash")
    """Hash of query group the query belongs to"""

    query_log_id = sgqlc.types.Field(String, graphql_name="queryLogId")
    """UUID of specific query"""

    query_type = sgqlc.types.Field(String, graphql_name="queryType")
    """The type of query that failed"""

    query_subtype = sgqlc.types.Field(String, graphql_name="querySubtype")
    """The sub-type of the query that failed"""

    user = sgqlc.types.Field(String, graphql_name="user")
    """The user who ran the query that failed"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """The RCA start time"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """The MCON of the table associated with the RCA"""


class Node(sgqlc.types.Interface):
    """An object with an ID"""

    __schema__ = schema
    __field_names__ = ("id",)
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")
    """The ID of the object."""


class NodeWithUUID(sgqlc.types.Interface):
    """Use this when the node has a uuid field. Uuid will be returned as
    the id of the node.
    """

    __schema__ = schema
    __field_names__ = ("id",)
    id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="id")


class RecommendationConfigInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = (
        "schedule_config",
        "resource_id",
        "description",
        "display_description",
        "notes",
        "type",
        "data_source",
        "labels",
        "reason",
    )
    schedule_config = sgqlc.types.Field(
        sgqlc.types.non_null("ScheduleConfig"), graphql_name="scheduleConfig"
    )

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")

    display_description = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="displayDescription"
    )

    notes = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="notes")

    type = sgqlc.types.Field(sgqlc.types.non_null(UserDefinedMonitors), graphql_name="type")

    data_source = sgqlc.types.Field(
        sgqlc.types.non_null(DataSourceInterface), graphql_name="dataSource"
    )

    labels = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="labels",
    )

    reason = sgqlc.types.Field(String, graphql_name="reason")


class ReportArgumentsInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type",)
    type = sgqlc.types.Field(sgqlc.types.non_null(ReportTypeEnum), graphql_name="type")


class ResponseMetadataInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type",)
    type = sgqlc.types.Field(sgqlc.types.non_null(ResponseMetadataType), graphql_name="type")


class ServiceNowCredentialsInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type",)
    type = sgqlc.types.Field(sgqlc.types.non_null(ServiceNowCredentialsType), graphql_name="type")


class WidgetDataSourceInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("data_source_id", "type")
    data_source_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dataSourceId")

    type = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardWidgetDataSourceType), graphql_name="type"
    )


class WidgetOptionsInterface(sgqlc.types.Interface):
    __schema__ = schema
    __field_names__ = ("type",)
    type = sgqlc.types.Field(sgqlc.types.non_null(CustomDashboardWidgetType), graphql_name="type")


class AIMessageOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("message", "actor", "status")
    message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message")
    """Message from the specified actor"""

    actor = sgqlc.types.Field(sgqlc.types.non_null(ActorType), graphql_name="actor")
    """The actor that sends the message"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """When streaming the results, it returns the status of the request"""


class AccessRequest(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "user_id",
        "status",
        "target_permission",
        "target_id",
        "reason",
        "created_time",
        "updated_time",
        "notified_admins",
    )
    id = sgqlc.types.Field(Int, graphql_name="id")
    """Unique identifier for the access request"""

    user_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="userId")
    """User who requested access"""

    status = sgqlc.types.Field(Status, graphql_name="status")
    """Current status of the access request"""

    target_permission = sgqlc.types.Field(
        sgqlc.types.non_null(Permission), graphql_name="targetPermission"
    )
    """Permission requested"""

    target_id = sgqlc.types.Field(String, graphql_name="targetId")
    """Object ID access was requested for"""

    reason = sgqlc.types.Field(String, graphql_name="reason")
    """Reason for requesting access"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the request was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the request was last updated"""

    notified_admins = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="notifiedAdmins")
    """List of admin emails that were notified about this request"""


class AccessRequestOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "access_request")
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """Whether the operation was successful"""

    access_request = sgqlc.types.Field(AccessRequest, graphql_name="accessRequest")
    """The access request object"""


class AccessToken(sgqlc.types.Type):
    """Generated API Token ID and Access Key. Only available once"""

    __schema__ = schema
    __field_names__ = ("id", "token")
    id = sgqlc.types.Field(String, graphql_name="id")
    """Token user ID"""

    token = sgqlc.types.Field(String, graphql_name="token")
    """Generated token"""


class Account(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "name",
        "created_on",
        "config",
        "allow_non_sso_login",
        "data_share",
        "is_deleted",
        "pending_deletion",
        "frozen_at",
        "notification_settings",
        "data_collectors",
        "users",
        "user_invites",
        "user_account_before_switch",
        "warehouses",
        "bi",
        "etl_containers",
        "connections",
        "alerts",
        "custom_sql_templates",
        "tablepartitionkeysmodel_set",
        "slack_credentials",
        "slack_channels",
        "slack_msg_details",
        "resources",
        "account_domains",
        "alation_integrations",
        "slack_credentials_v2",
        "collection_preferences",
        "asset_collection_preferences",
        "data_products",
        "opsgenie_integrations",
        "collibra_integrations",
        "agenttracetablemodel_set",
        "entitlements",
        "dashboards",
        "comparison_dashboards",
        "widgets",
        "identity_provider",
        "tableau_accounts",
        "use_monitor_domains",
        "validate_monitor_domains",
        "active_collection_regions",
        "internal_notifications",
        "can_generate_data_collector_template",
        "entitlements_limits",
        "monitor_limits",
        "statement_option",
        "statement_emails",
        "usage_alert_config",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """The account id"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """The account name"""

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")
    """When the account was first created"""

    config = sgqlc.types.Field(JSONString, graphql_name="config")
    """Account configuration"""

    allow_non_sso_login = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="allowNonSsoLogin"
    )

    data_share = sgqlc.types.Field(JSONString, graphql_name="dataShare")
    """Information necessary to setup a Snowflake Data Share"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    pending_deletion = sgqlc.types.Field(Date, graphql_name="pendingDeletion")
    """The date the account was marked as pending for deletion"""

    frozen_at = sgqlc.types.Field(DateTime, graphql_name="frozenAt")
    """When the account was frozen to pause monitors, notifications, and
    user access
    """

    notification_settings = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AccountNotificationSetting"))
        ),
        graphql_name="notificationSettings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "with_audience",
                    sgqlc.types.Arg(Boolean, graphql_name="withAudience", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `with_audience` (`Boolean`): If true, only settings associated
      to an audience will be returned. If false, only settings not
      associated will be returned. If not provided, all settings will
      be returned
    """

    data_collectors = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("DataCollector"))),
        graphql_name="dataCollectors",
    )

    users = sgqlc.types.Field(
        sgqlc.types.non_null("UserConnection"),
        graphql_name="users",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("email", sgqlc.types.Arg(String, graphql_name="email", default=None)),
                ("first_name", sgqlc.types.Arg(String, graphql_name="firstName", default=None)),
                ("last_name", sgqlc.types.Arg(String, graphql_name="lastName", default=None)),
                ("role", sgqlc.types.Arg(String, graphql_name="role", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `email` (`String`)None
    * `first_name` (`String`)None
    * `last_name` (`String`)None
    * `role` (`String`)None
    """

    user_invites = sgqlc.types.Field(
        sgqlc.types.non_null("UserInviteConnection"),
        graphql_name="userInvites",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `state` (`String`)None
    """

    user_account_before_switch = sgqlc.types.Field(
        sgqlc.types.non_null("UserInviteConnection"),
        graphql_name="userAccountBeforeSwitch",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `state` (`String`)None
    """

    warehouses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Warehouse"))),
        graphql_name="warehouses",
    )

    bi = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("BiContainer"))),
        graphql_name="bi",
    )

    etl_containers = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("EtlContainer"))),
        graphql_name="etlContainers",
    )

    connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Connection"))),
        graphql_name="connections",
    )

    alerts = sgqlc.types.Field(
        sgqlc.types.non_null("IncidentConnection"),
        graphql_name="alerts",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    custom_sql_templates = sgqlc.types.Field(
        sgqlc.types.non_null("CustomSQLTemplateConnection"),
        graphql_name="customSqlTemplates",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("sql_template", sgqlc.types.Arg(String, graphql_name="sqlTemplate", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        CustomSQLTemplateModelQueryResultType,
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `name` (`String`)None
    * `description` (`String`)None
    * `sql_template` (`String`)None
    * `dialect` (`String`)None
    * `query_result_type`
      (`CustomSQLTemplateModelQueryResultType`)None
    """

    tablepartitionkeysmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null("TablePartitionKeysConnection"),
        graphql_name="tablepartitionkeysmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    slack_credentials = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SlackCredentials"))),
        graphql_name="slackCredentials",
    )

    slack_channels = sgqlc.types.Field(
        sgqlc.types.non_null("SlackChannelV2Connection"),
        graphql_name="slackChannels",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """The account associated with the slack channel.

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    slack_msg_details = sgqlc.types.Field(
        sgqlc.types.non_null("SlackMessageDetailsConnection"),
        graphql_name="slackMsgDetails",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    resources = sgqlc.types.Field(
        sgqlc.types.non_null("ResourceConnection"),
        graphql_name="resources",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Customer account

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    account_domains = sgqlc.types.Field(
        sgqlc.types.non_null("DomainRestrictionConnection"),
        graphql_name="accountDomains",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Related account

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    alation_integrations = sgqlc.types.Field(
        sgqlc.types.non_null("AlationIntegrationConnection"),
        graphql_name="alationIntegrations",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    slack_credentials_v2 = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SlackCredentialsV2"))),
        graphql_name="slackCredentialsV2",
    )

    collection_preferences = sgqlc.types.Field(
        sgqlc.types.non_null("CollectionBlockConnection"),
        graphql_name="collectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    asset_collection_preferences = sgqlc.types.Field(
        sgqlc.types.non_null("AssetCollectionPreferencesConnection"),
        graphql_name="assetCollectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_products = sgqlc.types.Field(
        sgqlc.types.non_null("DataProductConnection"),
        graphql_name="dataProducts",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    opsgenie_integrations = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("OpsgenieIntegrationOutput"))
        ),
        graphql_name="opsgenieIntegrations",
    )

    collibra_integrations = sgqlc.types.Field(
        sgqlc.types.non_null("CollibraIntegrationConnection"),
        graphql_name="collibraIntegrations",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    agenttracetablemodel_set = sgqlc.types.Field(
        sgqlc.types.non_null("AgentTraceTableConnection"),
        graphql_name="agenttracetablemodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    entitlements = sgqlc.types.Field(
        sgqlc.types.list_of(EntitlementTypes), graphql_name="entitlements"
    )
    """Entitlements granted to the account"""

    dashboards = sgqlc.types.Field(
        sgqlc.types.non_null("DataExplorerDashboardTypeConnection"),
        graphql_name="dashboards",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    comparison_dashboards = sgqlc.types.Field(
        sgqlc.types.non_null("DataExplorerComparisonDashboardTypeConnection"),
        graphql_name="comparisonDashboards",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    widgets = sgqlc.types.Field(
        sgqlc.types.non_null("DataExplorerWidgetTypeConnection"),
        graphql_name="widgets",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    identity_provider = sgqlc.types.Field("SamlIdentityProvider", graphql_name="identityProvider")

    tableau_accounts = sgqlc.types.Field(
        sgqlc.types.list_of("TableauAccount"), graphql_name="tableauAccounts"
    )

    use_monitor_domains = sgqlc.types.Field(Boolean, graphql_name="useMonitorDomains")
    """Indicates whether the account is using monitor domains"""

    validate_monitor_domains = sgqlc.types.Field(Boolean, graphql_name="validateMonitorDomains")
    """Indicates whether the account is validating monitor domains"""

    active_collection_regions = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="activeCollectionRegions"
    )
    """AWS Regions where a DC can be hosted"""

    internal_notifications = sgqlc.types.Field(
        sgqlc.types.list_of("InternalNotifications"), graphql_name="internalNotifications"
    )
    """MC internal account notifications."""

    can_generate_data_collector_template = sgqlc.types.Field(
        Boolean, graphql_name="canGenerateDataCollectorTemplate"
    )
    """Indicates whether the account is allowed to generate a data
    collector template
    """

    entitlements_limits = sgqlc.types.Field(
        sgqlc.types.list_of("AccountEntitlementLimit"), graphql_name="entitlementsLimits"
    )

    monitor_limits = sgqlc.types.Field("MonitorLimits", graphql_name="monitorLimits")

    statement_option = sgqlc.types.Field(StatementOption, graphql_name="statementOption")
    """The account's preference for who should receive statement emails"""

    statement_emails = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="statementEmails"
    )
    """List of email addresses to receive statements"""

    usage_alert_config = sgqlc.types.Field(
        "UsageAlertConfigOutput", graphql_name="usageAlertConfig"
    )


class AccountAuditLog(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "timestamp",
        "account_uuid",
        "account_name",
        "email",
        "first_name",
        "last_name",
        "url",
        "event_type",
        "api_name",
        "api_is_query",
        "api_call_references",
        "api_call_source",
        "client_ip",
    )
    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")
    """Timestamp of the event"""

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accountUuid")
    """Account ID"""

    account_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accountName")
    """Account name"""

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")
    """Email of the user"""

    first_name = sgqlc.types.Field(String, graphql_name="firstName")
    """First name of the user"""

    last_name = sgqlc.types.Field(String, graphql_name="lastName")
    """Last name of the user"""

    url = sgqlc.types.Field(String, graphql_name="url")
    """URL on which the event occurred"""

    event_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="eventType")
    """Event type"""

    api_name = sgqlc.types.Field(String, graphql_name="apiName")
    """API name in case of GraphQL API calls"""

    api_is_query = sgqlc.types.Field(Boolean, graphql_name="apiIsQuery")
    """Whether a GraphQL API call is a query"""

    api_call_references = sgqlc.types.Field(String, graphql_name="apiCallReferences")
    """References (For instance UUIDs) passed as input parameters in
    GraphQL API calls
    """

    api_call_source = sgqlc.types.Field(String, graphql_name="apiCallSource")
    """Indicates the source of the GraphQL API call.For instance, `Web`
    or `Programmatic`
    """

    client_ip = sgqlc.types.Field(String, graphql_name="clientIp")
    """Client IP address"""


class AccountEntitlementLimit(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(EntitlementLimits), graphql_name="name")

    value = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="value")


class AccountEntitlementsInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("entitlements",)
    entitlements = sgqlc.types.Field(
        sgqlc.types.list_of(EntitlementTypes), graphql_name="entitlements"
    )


class AccountNotificationDigestSettings(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "interval_minutes",
        "start_time",
        "prev_execution_time",
        "next_execution_time",
        "created_time",
        "uuid",
        "digest_type",
        "routing_rules",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    interval_minutes = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="intervalMinutes")
    """Frequency interval in minutes to indicate how often to run the the
    schedule.
    """

    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")
    """First start time to run the schedule."""

    prev_execution_time = sgqlc.types.Field(DateTime, graphql_name="prevExecutionTime")
    """Previous successful execution time."""

    next_execution_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="nextExecutionTime"
    )
    """Scheduled time for next run."""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """Timestamp of when the schedule is created."""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique id of the digest settings."""

    digest_type = sgqlc.types.Field(
        sgqlc.types.non_null(AccountNotificationDigestSettingsModelDigestType),
        graphql_name="digestType",
    )
    """Type of digest."""

    routing_rules = sgqlc.types.Field("NotificationRoutingRule", graphql_name="routingRules")


class AccountNotificationRoutingRules(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "table_rules",
        "tag_rules",
        "sql_rules",
        "table_stats_rules",
        "domain_rules",
        "monitor_labels",
        "monitor_labels_match_type",
        "table_id_rules",
        "asset_rules",
        "anomaly_types",
        "incident_sub_types",
        "custom_message",
        "digest_settings",
        "audience",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "notification_settings",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """The route rule id"""

    table_rules = sgqlc.types.Field(String, graphql_name="tableRules")
    """Table/dataset based rules (regex)"""

    tag_rules = sgqlc.types.Field(JSONString, graphql_name="tagRules")
    """Key and key/value based rules"""

    sql_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="sqlRules"
    )
    """Custom sql rules"""

    table_stats_rules = sgqlc.types.Field(JSONString, graphql_name="tableStatsRules")
    """Rules based on table stats (importance_score, is_important)."""

    domain_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainRules"
    )
    """List of domain UUIDs to match event objects against."""

    monitor_labels = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="monitorLabels"
    )
    """labels"""

    monitor_labels_match_type = sgqlc.types.Field(
        sgqlc.types.non_null(AccountNotificationRoutingRulesModelMonitorLabelsMatchType),
        graphql_name="monitorLabelsMatchType",
    )
    """Specifies what logic operator to apply when matching labels"""

    table_id_rules = sgqlc.types.Field(JSONString, graphql_name="tableIdRules")
    """Project/dataset/table based rules"""

    asset_rules = sgqlc.types.Field(JSONString, graphql_name="assetRules")
    """Asset based rules"""

    anomaly_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="anomalyTypes"
    )
    """List of supported incident types to send notifications for"""

    incident_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="incidentSubTypes"
    )
    """All the incident sub-types this notification settings will alert
    on.
    """

    custom_message = sgqlc.types.Field(String, graphql_name="customMessage")
    """Custom text to be included with the notification"""

    digest_settings = sgqlc.types.Field(
        AccountNotificationDigestSettings, graphql_name="digestSettings"
    )
    """Digest notification settings for events matching the rule"""

    audience = sgqlc.types.Field("MonitorLabelObject", graphql_name="audience")
    """Routing rules per audience"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator of the routing rule"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Routing rule last updated by"""

    notification_settings = sgqlc.types.Field(
        "NotificationSetting", graphql_name="notificationSettings"
    )


class AccountNotificationSetting(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "deleted_at",
        "uuid",
        "created_by",
        "created_time",
        "last_updated_by",
        "last_update_time",
        "name",
        "is_template_managed",
        "namespace",
        "type",
        "recipients",
        "extra",
        "routing_rules",
        "notification_schedule_type",
        "notification_enabled",
        "audience",
        "slack_msg_details",
        "specification_rule",
        "recipient",
        "recipient_display_name",
        "recipients_display_names",
        "digest_settings",
        "permalink",
        "notification_count_history",
        "anomaly_types",
        "incident_sub_types",
        "alert_sub_types",
        "matching_incidents",
        "custom_message",
        "integration_id",
        "channel_url",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Effective ID for notification settings"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator of the notification"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the notification was first created"""

    last_updated_by = sgqlc.types.Field("User", graphql_name="lastUpdatedBy")
    """User who last updated this notification"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the notification was last updated"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Resource name for notifications created through notifications-as-
    code
    """

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )
    """Is this monitor managed by a configuration template
    (notifications-as-code)?
    """

    namespace = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="namespace")
    """Namespace of notification, used for notifications-as-code"""

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AccountNotificationSettingsModelType), graphql_name="type"
    )
    """Type of notification integration (e.g. slack)"""

    recipients = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="recipients"
    )
    """Destinations to send notifications to"""

    extra = sgqlc.types.Field(JSONString, graphql_name="extra")
    """Any additional information for various notification integrations"""

    routing_rules = sgqlc.types.Field(AccountNotificationRoutingRules, graphql_name="routingRules")

    notification_schedule_type = sgqlc.types.Field(
        sgqlc.types.non_null(AccountNotificationSettingsModelNotificationScheduleType),
        graphql_name="notificationScheduleType",
    )
    """Indicates whether the notification is of real time or digest types"""

    notification_enabled = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="notificationEnabled"
    )
    """When enabled notifications for this setting are sent."""

    audience = sgqlc.types.Field("MonitorLabelObject", graphql_name="audience")
    """Notification settings per audience"""

    slack_msg_details = sgqlc.types.Field(
        sgqlc.types.non_null("SlackMessageDetailsConnection"),
        graphql_name="slackMsgDetails",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    specification_rule = sgqlc.types.Field(String, graphql_name="specificationRule")
    """Deprecated. Use routingRules tableRules."""

    recipient = sgqlc.types.Field(String, graphql_name="recipient")
    """Deprecated. Use recipients instead."""

    recipient_display_name = sgqlc.types.Field(String, graphql_name="recipientDisplayName")

    recipients_display_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="recipientsDisplayNames"
    )

    digest_settings = sgqlc.types.Field(
        AccountNotificationDigestSettings, graphql_name="digestSettings"
    )

    permalink = sgqlc.types.Field(String, graphql_name="permalink")

    notification_count_history = sgqlc.types.Field(
        sgqlc.types.list_of("NotificationDailyCount"), graphql_name="notificationCountHistory"
    )
    """Number of incidents per day for the past 30 days"""

    anomaly_types = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="anomalyTypes")
    """Limit notifications to specific incident types (default=all).
    Supported options include: anomalies, schema_changes,
    json_schema_changes, deleted_tables, metric_anomalies,
    agent_anomalies, metric_comparison_anomalies,
    custom_rule_anomalies, performance_anomalies, dbt_errors,
    etl_errors, pseudo_integration_test, rule_run_execution_error,
    merged
    """

    incident_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentSubType), graphql_name="incidentSubTypes"
    )
    """Limit notifications to specific incident sub types (default=all)."""

    alert_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(AlertSubType), graphql_name="alertSubTypes"
    )
    """Limit notifications to specific alert sub types (default=all)."""

    matching_incidents = sgqlc.types.Field(Int, graphql_name="matchingIncidents")

    custom_message = sgqlc.types.Field(String, graphql_name="customMessage")
    """Message to add on every notification"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Integration ID for the recipient"""

    channel_url = sgqlc.types.Field(String, graphql_name="channelUrl")
    """URL of the channel if this is a channel-based notification.
    Currently only Slack and MS Teams is supported.
    """


class AccountSecretOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "scope",
        "description",
        "expires_at",
        "value",
        "created_by",
        "created_at",
        "updated_by",
        "last_update",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The secret name"""

    scope = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="scope")
    """The secret scope"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """The secret description"""

    expires_at = sgqlc.types.Field(DateTime, graphql_name="expiresAt")
    """When does the secret expire. Null if it doesn't expire."""

    value = sgqlc.types.Field(String, graphql_name="value")
    """The secret value. Can only be accessed under specific conditions
    and by explicitly asking it with the 'reveal' option.
    """

    created_by = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="createdBy")
    """The user that created the secret"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")
    """When the secret was created"""

    updated_by = sgqlc.types.Field(String, graphql_name="updatedBy")
    """The user that updated the secret"""

    last_update = sgqlc.types.Field(DateTime, graphql_name="lastUpdate")
    """When the secret was last updated"""


class AccountUsageObject(sgqlc.types.Type):
    """Account usage and consumption."""

    __schema__ = schema
    __field_names__ = ("ingested", "monitored", "timestamp")
    ingested = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="ingested")
    """Number of ingested tables"""

    monitored = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="monitored")
    """Number of monitored tables"""

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """Timestamp of the usage record."""


class ActiveNodeDetails(sgqlc.types.Type):
    """Active node information"""

    __schema__ = schema
    __field_names__ = (
        "name",
        "stack_arn",
        "uuid",
        "code_version",
        "template_version",
        "private_cidr",
        "private_ip_addresses",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Node Name"""

    stack_arn = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="stackArn")
    """Stack ARN"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Node UUID"""

    code_version = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="codeVersion")
    """Code Version"""

    template_version = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="templateVersion"
    )
    """Template Version"""

    private_cidr = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="privateCidr"
    )
    """Private CIDR"""

    private_ip_addresses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="privateIpAddresses"
    )
    """List of Private IP addresses"""


class AddAllowListEntry(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "project_name", "dataset")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""

    project_name = sgqlc.types.Field(String, graphql_name="projectName")
    """The project name for which the dataset was added."""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """The dataset name that was added."""


class AddBiConnectionMutation(sgqlc.types.Type):
    """Add a bi connection and setup any associated jobs"""

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field("Connection", graphql_name="connection")


class AddConnectionMutation(sgqlc.types.Type):
    """Add a connection and setup any associated jobs. Creates a
    warehouse if not specified
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field("Connection", graphql_name="connection")


class AddDatabricksConnectionMutation(sgqlc.types.Type):
    """Add a databricks connection and setup any associated jobs. Creates
    a warehouse if not specified
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field("Connection", graphql_name="connection")


class AddEtlConnectionMutation(sgqlc.types.Type):
    """Add an etl connection and setup any associated jobs"""

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field("Connection", graphql_name="connection")


class AddMonitorsLabels(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class AddOrUpdateCustomDashboardWidget(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("widget",)
    widget = sgqlc.types.Field(sgqlc.types.non_null("CustomDashboardWidget"), graphql_name="widget")


class AddPlatformService(sgqlc.types.Type):
    """Adds a new platform service to the account, restricted operation."""

    __schema__ = schema
    __field_names__ = ("service_uuid",)
    service_uuid = sgqlc.types.Field(UUID, graphql_name="serviceUuid")
    """The UUID of to the new service"""


class AddRedshiftConsumerConnectionMutation(sgqlc.types.Type):
    """Add a Redshift consumer connection. Used for DataShare lineage."""

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field("Connection", graphql_name="connection")


class AddStreamingConnectionMutation(sgqlc.types.Type):
    """Add a connection for a streaming cluster and setup any associated
    jobs. Creates a streaming cluster if a cluster if not specified.
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field("Connection", graphql_name="connection")


class AddStreamingSystemMutation(sgqlc.types.Type):
    """Add a streaming system, which contains a set of streaming clusters
    that work together in the system.
    """

    __schema__ = schema
    __field_names__ = ("streaming_system",)
    streaming_system = sgqlc.types.Field("StreamingSystem", graphql_name="streamingSystem")


class AddToCollectionBlockList(sgqlc.types.Type):
    """Adds to the list of entities for which metadata collection is not
    allowed on this account.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class AdditionalData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "projects_validated",
        "datasets_validated",
        "tables_validated",
        "queries_with_results",
        "returned_data",
    )
    projects_validated = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="projectsValidated"
    )
    """Projects that were validated."""

    datasets_validated = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="datasetsValidated"
    )
    """Datasets that were validated."""

    tables_validated = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="tablesValidated"
    )
    """Tables that were validated."""

    queries_with_results = sgqlc.types.Field(
        sgqlc.types.list_of("QueryWithResults"), graphql_name="queriesWithResults"
    )
    """Queries that were executed for validation along with their
    results.
    """

    returned_data = sgqlc.types.Field(GenericScalar, graphql_name="returnedData")
    """JSON object containing all data returned from validation."""


class AdditionalMonitoredTablesCountOutput(sgqlc.types.Type):
    """Number of additional tables that would be monitored by"""

    __schema__ = schema
    __field_names__ = ("count", "total_count")
    count = sgqlc.types.Field(Int, graphql_name="count")
    """Number of additional tables that would be monitored by current and
    new rules if applied
    """

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of tables encapsulated by the rule (both currently
    monitored and unmonitored)
    """


class AdfJobConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AdfJobEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AdfJobEdge(sgqlc.types.Type):
    """A Relay edge containing a `AdfJob` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AdfJob", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AdfJobRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AdfJobRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AdfJobRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `AdfJobRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AdfJobRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AdfJobRunsConnection(sgqlc.types.relay.Connection):
    """ADF job executions response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AdfJobRunsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class AdfJobRunsEdge(sgqlc.types.Type):
    """A Relay edge containing a `AdfJobRuns` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AdfJobRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AdfTaskConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AdfTaskEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AdfTaskEdge(sgqlc.types.Type):
    """A Relay edge containing a `AdfTask` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AdfTask", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AdfTaskRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AdfTaskRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AdfTaskRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `AdfTaskRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AdfTaskRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class Agent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "name",
        "data_collector",
        "endpoint",
        "platform",
        "agent_type",
        "wrapper_type",
        "auth_type",
        "storage_type",
        "credentials_s3_key",
        "created_time",
        "last_updated_time",
        "wrapper_version",
        "image_build",
        "image_version",
        "is_remote_upgradeable",
        "is_deleted",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")
    """Unique ID of the Agent."""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique UUID of the Agent."""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Name of the Agent."""

    data_collector = sgqlc.types.Field(
        sgqlc.types.non_null("DataCollector"), graphql_name="dataCollector"
    )
    """Data Collector the Agent is registered to."""

    endpoint = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="endpoint")
    """The address of the Agent; bucket name, IP address, URL, etc."""

    platform = sgqlc.types.Field(AgentModelPlatform, graphql_name="platform")
    """The cloud platform the Agent is deployed in."""

    agent_type = sgqlc.types.Field(
        sgqlc.types.non_null(AgentModelAgentType), graphql_name="agentType"
    )
    """Type of Agent deployed."""

    wrapper_type = sgqlc.types.Field(AgentModelWrapperType, graphql_name="wrapperType")
    """Type of MC provided wrapper, if any."""

    auth_type = sgqlc.types.Field(sgqlc.types.non_null(AgentModelAuthType), graphql_name="authType")
    """The authorization type used to connect to this Agent."""

    storage_type = sgqlc.types.Field(
        sgqlc.types.non_null(AgentModelStorageType), graphql_name="storageType"
    )
    """Type of data store used by this Agent."""

    credentials_s3_key = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="credentialsS3Key"
    )
    """Key to the credentials vault. Used to look up the agent
    credentials.
    """

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """Timestamp of when agent was registered."""

    last_updated_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdatedTime")
    """Timestamp of the last image version update."""

    wrapper_version = sgqlc.types.Field(String, graphql_name="wrapperVersion")
    """If using an MC wrapper, the version number"""

    image_build = sgqlc.types.Field(String, graphql_name="imageBuild")
    """Build number of agent image. Null if agent_type is
    DATA_STORE_AGENT
    """

    image_version = sgqlc.types.Field(String, graphql_name="imageVersion")
    """Docker image version of the agent. Null if agent_type is
    DATA_STORE_AGENT
    """

    is_remote_upgradeable = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isRemoteUpgradeable"
    )
    """True if Monte Carlo has access to update the image version of the
    remote agent.
    """

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")
    """If the Agent is deregistered from the DC, this field will be
    'true', allowing the customer to register a different Agent with
    the data collector.
    """


class AgentLogEntry(sgqlc.types.Type):
    """A log entry from an agent."""

    __schema__ = schema
    __field_names__ = ("timestamp", "payload")
    timestamp = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timestamp")
    """Timestamp for the log entry."""

    payload = sgqlc.types.Field(GenericScalar, graphql_name="payload")
    """The JSON payload in the log entry. If the entry is a text message,
    then a dictionary with a single 'message' attribute is returned.
    """


class AgentMetadata(sgqlc.types.Type):
    """Metadata about AI agents for agent observability."""

    __schema__ = schema
    __field_names__ = ("account_uuid", "agent_name", "trace_table_mcon")
    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")
    """Account UUID"""

    agent_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="agentName")
    """Name of the agent"""

    trace_table_mcon = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="traceTableMcon"
    )
    """MCON of the trace table associated with this agent"""


class AgentSpanFieldFilter(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value",)
    value = sgqlc.types.Field(String, graphql_name="value")


class AgentSpanFilter(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("agent", "workflow", "task", "span_name")
    agent = sgqlc.types.Field(AgentSpanFieldFilter, graphql_name="agent")

    workflow = sgqlc.types.Field(AgentSpanFieldFilter, graphql_name="workflow")

    task = sgqlc.types.Field(AgentSpanFieldFilter, graphql_name="task")

    span_name = sgqlc.types.Field(AgentSpanFieldFilter, graphql_name="spanName")


class AgentSpanNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("node_name", "node_value", "child_nodes", "level", "count", "is_leaf")
    node_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="nodeName")

    node_value = sgqlc.types.Field(String, graphql_name="nodeValue")

    child_nodes = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("AgentSpanNode"))),
        graphql_name="childNodes",
    )

    level = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="level")

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")

    is_leaf = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isLeaf")


class AgentSpanTree(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes", "query")
    nodes = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanNode))),
        graphql_name="nodes",
    )

    query = sgqlc.types.Field(String, graphql_name="query")


class AgentTraceTableConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AgentTraceTableEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AgentTraceTableEdge(sgqlc.types.Type):
    """A Relay edge containing a `AgentTraceTable` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AgentTraceTable", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AggregatedMetricDataType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query_group", "metric_aggregation", "timestamp", "value")
    query_group = sgqlc.types.Field(String, graphql_name="queryGroup")
    """Query group identifier"""

    metric_aggregation = sgqlc.types.Field(
        "MetricAggregationOutputType", graphql_name="metricAggregation"
    )
    """Metric aggregation"""

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """Aggregated data timestamp"""

    value = sgqlc.types.Field(Float, graphql_name="value")
    """Aggregated data value"""


class AggregatedQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "date",
        "group_id",
        "query_hash",
        "user",
        "category",
        "latest_query",
        "latest_query_id",
        "latest_query_timestamp",
        "count",
        "average_run_time",
    )
    date = sgqlc.types.Field(Date, graphql_name="date")
    """Date the queries occurred on"""

    group_id = sgqlc.types.Field(String, graphql_name="groupId")
    """Hash that is shared by all the aggregated queries for writes"""

    query_hash = sgqlc.types.Field(String, graphql_name="queryHash")
    """Hash that is shared by all the aggregated queries for reads"""

    user = sgqlc.types.Field(String, graphql_name="user")
    """User of the aggregated queries"""

    category = sgqlc.types.Field(QueryCategory, graphql_name="category")
    """Category of the aggregated queries"""

    latest_query = sgqlc.types.Field(String, graphql_name="latestQuery")
    """Substring of the latest query from the aggregated group containing
    the first n characters defined by the query_characters parameter
    in the request
    """

    latest_query_id = sgqlc.types.Field(String, graphql_name="latestQueryId")
    """ID of the latest query"""

    latest_query_timestamp = sgqlc.types.Field(DateTime, graphql_name="latestQueryTimestamp")
    """Timestamp of the latest query"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Count of the number of queries aggregated"""

    average_run_time = sgqlc.types.Field(Int, graphql_name="averageRunTime")
    """Average run time of the aggregated queries in milliseconds"""


class AggregatedQueryResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("aggregated_queries", "page_info")
    aggregated_queries = sgqlc.types.Field(
        sgqlc.types.list_of(AggregatedQuery), graphql_name="aggregatedQueries"
    )
    """List of aggregated queries which are grouped based on their group
    ID
    """

    page_info = sgqlc.types.Field("NextPageInfo", graphql_name="pageInfo")
    """Data necessary to paginate aggregated queries"""


class AiAgent(sgqlc.types.Type):
    """AI Agent configuration for an account."""

    __schema__ = schema
    __field_names__ = ("created_time", "updated_time", "agent_type", "context_prompt")
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    agent_type = sgqlc.types.Field(sgqlc.types.non_null(AiAgentType), graphql_name="agentType")

    context_prompt = sgqlc.types.Field(String, graphql_name="contextPrompt")
    """Custom context prompt for the AI agent"""


class AirflowCapabilitiesResponse(sgqlc.types.Type):
    """Airflow capabilities information"""

    __schema__ = schema
    __field_names__ = (
        "has_connection",
        "has_callbacks",
        "uses_deprecated_graphql",
        "webhook_status",
    )
    has_connection = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasConnection")
    """True if the account has a connection set up"""

    has_callbacks = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasCallbacks")
    """True if the account has callbacks set up"""

    uses_deprecated_graphql = sgqlc.types.Field(Boolean, graphql_name="usesDeprecatedGraphql")
    """True if using deprecated GraphQL implementation instead of
    callbacks
    """

    webhook_status = sgqlc.types.Field("WebhookStatus", graphql_name="webhookStatus")
    """Webhook status information (only for callback implementation)"""


class AirflowDagConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AirflowDagEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AirflowDagEdge(sgqlc.types.Type):
    """A Relay edge containing a `AirflowDag` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AirflowDag", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AirflowDagRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AirflowDagRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AirflowDagRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `AirflowDagRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AirflowDagRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AirflowDagRunInfo(sgqlc.types.Type):
    """Airflow DAG Run information"""

    __schema__ = schema
    __field_names__ = ("run_id", "start_date", "end_date", "success", "duration", "error", "state")
    run_id = sgqlc.types.Field(String, graphql_name="runId")
    """Run ID"""

    start_date = sgqlc.types.Field(DateTime, graphql_name="startDate")
    """Start date"""

    end_date = sgqlc.types.Field(DateTime, graphql_name="endDate")
    """End date"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Run was completed successfully"""

    duration = sgqlc.types.Field(Float, graphql_name="duration")
    """Run duration in seconds"""

    error = sgqlc.types.Field(String, graphql_name="error")
    """Error message in case of failure"""

    state = sgqlc.types.Field(sgqlc.types.non_null(AirflowRunState), graphql_name="state")
    """Current state of the run"""


class AirflowTaskConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AirflowTaskEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AirflowTaskEdge(sgqlc.types.Type):
    """A Relay edge containing a `AirflowTask` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AirflowTask", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AirflowTaskRunAttempt(sgqlc.types.Type):
    """Individual attempt details for an Airflow task run"""

    __schema__ = schema
    __field_names__ = (
        "attempt_number",
        "start_date",
        "end_date",
        "state",
        "success",
        "duration",
        "exception_message",
    )
    attempt_number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="attemptNumber")
    """Attempt number"""

    start_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startDate")
    """Attempt start time"""

    end_date = sgqlc.types.Field(DateTime, graphql_name="endDate")
    """Attempt end time"""

    state = sgqlc.types.Field(sgqlc.types.non_null(AirflowRunState), graphql_name="state")
    """Attempt state"""

    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """Whether attempt succeeded"""

    duration = sgqlc.types.Field(Float, graphql_name="duration")
    """Attempt duration in seconds"""

    exception_message = sgqlc.types.Field(String, graphql_name="exceptionMessage")
    """Error message if failed"""


class AirflowTaskRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AirflowTaskRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AirflowTaskRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `AirflowTaskRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AirflowTaskRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AirflowTaskRunStats(sgqlc.types.Type):
    """Airflow Task Run statistics"""

    __schema__ = schema
    __field_names__ = (
        "num_run_success",
        "num_run_failure",
        "num_run_running",
        "avg_duration",
        "last_run",
        "task_id",
        "dag_id",
        "resource__name",
        "task_mcon",
        "job_mcon",
        "urls",
    )
    num_run_success = sgqlc.types.Field(Int, graphql_name="numRunSuccess")
    """Number of successful tasks"""

    num_run_failure = sgqlc.types.Field(Int, graphql_name="numRunFailure")
    """Number of failed tasks"""

    num_run_running = sgqlc.types.Field(Int, graphql_name="numRunRunning")
    """Number of running tasks"""

    avg_duration = sgqlc.types.Field(Float, graphql_name="avgDuration")
    """Average duration of tasks"""

    last_run = sgqlc.types.Field(DateTime, graphql_name="lastRun")
    """Last run timestamp of tasks"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID of Airflow task"""

    dag_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dagId")
    """DAG ID of Airflow DAG"""

    resource__name = sgqlc.types.Field(String, graphql_name="resource_Name")
    """Resource name of Airflow connection"""

    task_mcon = sgqlc.types.Field(String, graphql_name="taskMcon")
    """MCON of Task for provided task_id"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of Job for provided job_id"""

    urls = sgqlc.types.Field("AirflowUrls", graphql_name="urls")
    """URLs to Airflow UI"""


class AirflowTaskRunStatsConnection(sgqlc.types.relay.Connection):
    """Airflow Task Run statistics response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AirflowTaskRunStatsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AirflowTaskRunStatsEdge(sgqlc.types.Type):
    """A Relay edge containing a `AirflowTaskRunStats` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(AirflowTaskRunStats, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AirflowUrls(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dag", "dag_run", "task_run")
    dag = sgqlc.types.Field(String, graphql_name="dag")
    """URL to Airflow UI for the DAG"""

    dag_run = sgqlc.types.Field(String, graphql_name="dagRun")
    """URL to Airflow UI for the DAG run"""

    task_run = sgqlc.types.Field(String, graphql_name="taskRun")
    """URL to Airflow UI for the task run"""


class AlationIntegrationConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AlationIntegrationEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AlationIntegrationEdge(sgqlc.types.Type):
    """A Relay edge containing a `AlationIntegration` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AlationIntegration", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AlertAccessRequest(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "user_id",
        "alert_id",
        "status",
        "created_time",
        "updated_time",
        "notified_admins",
    )
    id = sgqlc.types.Field(Int, graphql_name="id")
    """Unique identifier for the access request"""

    user_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="userId")
    """User who requested access"""

    alert_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="alertId")
    """Alert ID access was requested for"""

    status = sgqlc.types.Field(AlertAccessRequestStatus, graphql_name="status")
    """Current status of the access request"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the request was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the request was last updated"""

    notified_admins = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="notifiedAdmins")
    """List of admin emails that were notified about this request"""


class AlertAccessRequestOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "access_request")
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """Whether the operation was successful"""

    access_request = sgqlc.types.Field(AlertAccessRequest, graphql_name="accessRequest")
    """The access request object"""


class AlertConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AlertEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")


class AlertDescriptionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("description",)
    description = sgqlc.types.Field(String, graphql_name="description")


class AlertEdge(sgqlc.types.Type):
    """A Relay edge containing a `Alert` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("Alert", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AlertRcaData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("primary_rca", "event_rcas", "alert_rcas")
    primary_rca = sgqlc.types.Field("PrimaryRcaData", graphql_name="primaryRca")

    event_rcas = sgqlc.types.Field(sgqlc.types.list_of("EventRcaData"), graphql_name="eventRcas")

    alert_rcas = sgqlc.types.Field(
        sgqlc.types.list_of("AlertScopedRcaData"), graphql_name="alertRcas"
    )


class AlertReaction(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("type", "reasons", "notes")
    type = sgqlc.types.Field(sgqlc.types.non_null(AlertReactionType), graphql_name="type")

    reasons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AlertReactionReason))),
        graphql_name="reasons",
    )

    notes = sgqlc.types.Field(String, graphql_name="notes")


class AlertTimePeriodAggregateData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("start_date", "end_date", "values")
    start_date = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="startDate")
    """The start date for the aggregated data"""

    end_date = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="endDate")
    """The end date for the aggregated data"""

    values = sgqlc.types.Field(sgqlc.types.list_of("LabelCount"), graphql_name="values")
    """The aggregate label and count for the time time period"""


class AlertTypeSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "anomalies",
        "schema_changes",
        "json_schema_changes",
        "deleted_tables",
        "metric_anomalies",
        "agent_anomalies",
        "metric_comparison_anomalies",
        "custom_rule_anomalies",
        "performance_anomalies",
        "dbt_errors",
        "etl_errors",
        "pseudo_integration_test",
        "rule_run_execution_error",
        "merged",
    )
    anomalies = sgqlc.types.Field(Int, graphql_name="anomalies")

    schema_changes = sgqlc.types.Field(Int, graphql_name="schemaChanges")

    json_schema_changes = sgqlc.types.Field(Int, graphql_name="jsonSchemaChanges")

    deleted_tables = sgqlc.types.Field(Int, graphql_name="deletedTables")

    metric_anomalies = sgqlc.types.Field(Int, graphql_name="metricAnomalies")

    agent_anomalies = sgqlc.types.Field(Int, graphql_name="agentAnomalies")

    metric_comparison_anomalies = sgqlc.types.Field(Int, graphql_name="metricComparisonAnomalies")

    custom_rule_anomalies = sgqlc.types.Field(Int, graphql_name="customRuleAnomalies")

    performance_anomalies = sgqlc.types.Field(Int, graphql_name="performanceAnomalies")

    dbt_errors = sgqlc.types.Field(Int, graphql_name="dbtErrors")

    etl_errors = sgqlc.types.Field(Int, graphql_name="etlErrors")

    pseudo_integration_test = sgqlc.types.Field(Int, graphql_name="pseudoIntegrationTest")

    rule_run_execution_error = sgqlc.types.Field(Int, graphql_name="ruleRunExecutionError")

    merged = sgqlc.types.Field(Int, graphql_name="merged")


class AlertWeeklyDataDashboard(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("weekly_data",)
    weekly_data = sgqlc.types.Field(
        sgqlc.types.list_of(AlertTimePeriodAggregateData), graphql_name="weeklyData"
    )
    """The weekly alert data"""


class AlertsCountByDate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("date", "count")
    date = sgqlc.types.Field(Date, graphql_name="date")
    """Alert updated date"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Count of alerts on the date"""


class AlertsCountByDateConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AlertsCountByDateEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AlertsCountByDateEdge(sgqlc.types.Type):
    """A Relay edge containing a `AlertsCountByDate` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(AlertsCountByDate, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AlertsFilter(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "field_name",
        "display_name",
        "query_parameter_name",
        "query_parameter_accepts_multiple_values",
        "facetable",
        "facet_searchable",
    )
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsFilterFieldName), graphql_name="fieldName"
    )

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")

    query_parameter_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="queryParameterName"
    )
    """Associated getAlerts parameter used to filter alerts"""

    query_parameter_accepts_multiple_values = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="queryParameterAcceptsMultipleValues"
    )
    """Whether the associated getAlerts parameter accepts multiple values
    as input
    """

    facetable = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="facetable")
    """Whether the filter shows up as a facet on the alert feed page"""

    facet_searchable = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="facetSearchable"
    )
    """Whether the filter values can be searched by their display name"""


class AlertsFilterData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "values", "page_info")
    field_name = sgqlc.types.Field(AlertsFilterFieldName, graphql_name="fieldName")

    values = sgqlc.types.Field(sgqlc.types.list_of("AlertsFilterDataValue"), graphql_name="values")
    """List of possible values to filter alerts by"""

    page_info = sgqlc.types.Field("NextPageInfo", graphql_name="pageInfo")
    """Data for paginating values"""


class AlertsFilterDataValue(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value", "display_name", "count", "child_values", "query_parameter_name")
    value = sgqlc.types.Field(GenericScalar, graphql_name="value")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    count = sgqlc.types.Field(Int, graphql_name="count")

    child_values = sgqlc.types.Field(
        sgqlc.types.list_of("AlertsFilterDataValue"), graphql_name="childValues"
    )

    query_parameter_name = sgqlc.types.Field(String, graphql_name="queryParameterName")
    """If this has a value, it should override the value from
    AlertsFilter
    """


class ApiUsageLimits(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_requests_per_day", "requests_per_second", "burst_limit")
    total_requests_per_day = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="totalRequestsPerDay"
    )

    requests_per_second = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="requestsPerSecond"
    )

    burst_limit = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="burstLimit")


class ApiUsageResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("limits", "usage")
    limits = sgqlc.types.Field(sgqlc.types.non_null(ApiUsageLimits), graphql_name="limits")

    usage = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("DailyUsage"))),
        graphql_name="usage",
    )


class AssetCollectionPreferencesConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AssetCollectionPreferencesEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class AssetCollectionPreferencesEdge(sgqlc.types.Type):
    """A Relay edge containing a `AssetCollectionPreferences` and its
    cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AssetCollectionPreferences", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AssetCollectionRule(sgqlc.types.Type):
    """Asset collection rule."""

    __schema__ = schema
    __field_names__ = ("conditions", "effect")
    conditions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AssetCollectionRuleCondition")),
        graphql_name="conditions",
    )
    """The set of conditions that need to match in order for this rule to
    apply
    """

    effect = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionRuleEffect), graphql_name="effect"
    )
    """Whether to allow or block the asset when this rule matches."""


class AssetCollectionRuleCondition(sgqlc.types.Type):
    """Asset collection rule condition."""

    __schema__ = schema
    __field_names__ = ("attribute_name", "value", "comparison_type")
    attribute_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="attributeName")
    """The name of the attribute to match"""

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """The value (or pattern) to compare the attribute against"""

    comparison_type = sgqlc.types.Field(
        CollectionPreferenceMatchType, graphql_name="comparisonType"
    )
    """The method for comparing the attribute to the given value"""


class AssetIncludeDatabase(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "schemas")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    schemas = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="schemas"
    )


class AssetSelection(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("databases", "filters", "exclusions")
    databases = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AssetIncludeDatabase))),
        graphql_name="databases",
    )

    filters = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AssetFilterInterface))),
        graphql_name="filters",
    )

    exclusions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AssetFilterInterface))),
        graphql_name="exclusions",
    )


class AssetSelectionResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "id",
        "type",
        "count",
        "count_unselected",
        "count_database_schema",
        "selected",
        "mcon",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")

    count_unselected = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="countUnselected")

    count_database_schema = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="countDatabaseSchema"
    )

    selected = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="selected")

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")


class AssetUsageNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "mcon_id",
        "display_name",
        "path",
        "schema_count_is_ingested",
        "schema_count_is_not_ingested",
        "table_count",
        "table_count_is_ingested",
        "table_count_is_not_ingested",
        "table_count_is_monitored",
        "table_count_is_not_monitored",
        "is_excluded",
        "is_monitored",
        "importance_score",
        "last_activity",
        "last_read",
        "last_write",
        "last_volume_change",
        "object_properties",
        "table_type",
    )
    mcon_id = sgqlc.types.Field(String, graphql_name="mconId")
    """MCON of the object represented by this node."""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """User-friendly display name of the catalog object."""

    path = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="path")
    """Object's hierarchy as list of ancestors plus self, if applicable."""

    schema_count_is_ingested = sgqlc.types.Field(Int, graphql_name="schemaCountIsIngested")
    """The number of schemas associated with this node that are ingested."""

    schema_count_is_not_ingested = sgqlc.types.Field(Int, graphql_name="schemaCountIsNotIngested")
    """The number of schemas associated with this node that are not
    ingested.
    """

    table_count = sgqlc.types.Field(Int, graphql_name="tableCount")
    """The number of tables associated with this node."""

    table_count_is_ingested = sgqlc.types.Field(Int, graphql_name="tableCountIsIngested")
    """The number of tables associated with this node that are ingested."""

    table_count_is_not_ingested = sgqlc.types.Field(Int, graphql_name="tableCountIsNotIngested")
    """The number of tables associated with this node that are not
    ingested.
    """

    table_count_is_monitored = sgqlc.types.Field(Int, graphql_name="tableCountIsMonitored")
    """The number of tables associated with this node that are monitored."""

    table_count_is_not_monitored = sgqlc.types.Field(Int, graphql_name="tableCountIsNotMonitored")
    """The number of tables associated with this node that are not
    monitored.
    """

    is_excluded = sgqlc.types.Field(Boolean, graphql_name="isExcluded")
    """Whether or not a table node is excluded from ingestion control.
    When it is True, it means that the table is excluded for
    ingestion.
    """

    is_monitored = sgqlc.types.Field(Boolean, graphql_name="isMonitored")
    """Whether or not a table node is monitored. When it is False, it
    means that the table is not monitored.
    """

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """The importance score of the table."""

    last_activity = sgqlc.types.Field(DateTime, graphql_name="lastActivity")
    """The last activity date of the table. When was the last time the
    table was read or written.
    """

    last_read = sgqlc.types.Field(DateTime, graphql_name="lastRead")
    """The last read date of the table. When was the last time the table
    was read from.
    """

    last_write = sgqlc.types.Field(DateTime, graphql_name="lastWrite")
    """The last write date of the table. When was the last time the table
    was written to .
    """

    last_volume_change = sgqlc.types.Field(DateTime, graphql_name="lastVolumeChange")
    """The last time a significant write was executed on the table"""

    object_properties = sgqlc.types.Field(
        sgqlc.types.list_of("PartialObjectProperty"), graphql_name="objectProperties"
    )
    """Properties of the table (like tags)."""

    table_type = sgqlc.types.Field(String, graphql_name="tableType")
    """The type of the table."""


class AssetsUsageResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "nodes",
        "has_next_page",
        "next_page_offset",
        "group_object_type",
        "total_count",
    )
    nodes = sgqlc.types.Field(sgqlc.types.list_of(AssetUsageNode), graphql_name="nodes")
    """Nodes for current page."""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """If there are more nodes."""

    next_page_offset = sgqlc.types.Field(Int, graphql_name="nextPageOffset")
    """Where to start for next page, if next page exists."""

    group_object_type = sgqlc.types.Field(String, graphql_name="groupObjectType")
    """Object type of the group, when grouping by type."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of nodes."""


class AssignmentWithProperties(sgqlc.types.Type):
    """Domain Assignment configuration"""

    __schema__ = schema
    __field_names__ = (
        "mcon",
        "display_name",
        "resource_type",
        "resource_uuid",
        "resource_name",
        "object_type",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of the object assigned to a domain"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Display name of the object assigned to a domain"""

    resource_type = sgqlc.types.Field(String, graphql_name="resourceType")
    """Resource type of the object assigned to a domain"""

    resource_uuid = sgqlc.types.Field(UUID, graphql_name="resourceUuid")
    """Resource uuid of the object assigned to a domain"""

    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """Resource name of the object assigned to a domain"""

    object_type = sgqlc.types.Field(String, graphql_name="objectType")
    """Type of object assigned to a domain"""


class Audience(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "label")
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")


class AudienceMonitorConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AudienceMonitorEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AudienceMonitorEdge(sgqlc.types.Type):
    """A Relay edge containing a `AudienceMonitor` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AudienceMonitor", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AudienceRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "label")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """Audience UUID"""

    label = sgqlc.types.Field(String, graphql_name="label")
    """Audience label"""


class AudienceRoutingStats(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "audience_uuid",
        "audience_label",
        "mcons_covered_by_table_monitors",
        "mcons_covered_by_notification_routing",
        "mcons_covered_by_notification_routing_excluding_importance",
        "sample_mcons_routing_not_table_monitor",
        "sample_mcons_routing_not_table_monitor_excluding_importance",
        "sample_mcons_table_monitor_not_routing",
        "uses_monitoring_filters_fallback",
        "mcons_new_routed_from_importance",
        "ignored_routing_rules",
    )
    audience_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="audienceUuid")

    audience_label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="audienceLabel")

    mcons_covered_by_table_monitors = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsCoveredByTableMonitors"
    )

    mcons_covered_by_notification_routing = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsCoveredByNotificationRouting"
    )

    mcons_covered_by_notification_routing_excluding_importance = sgqlc.types.Field(
        sgqlc.types.non_null(Int),
        graphql_name="mconsCoveredByNotificationRoutingExcludingImportance",
    )

    sample_mcons_routing_not_table_monitor = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsRoutingNotTableMonitor",
    )

    sample_mcons_routing_not_table_monitor_excluding_importance = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsRoutingNotTableMonitorExcludingImportance",
    )

    sample_mcons_table_monitor_not_routing = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsTableMonitorNotRouting",
    )

    uses_monitoring_filters_fallback = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usesMonitoringFiltersFallback"
    )

    mcons_new_routed_from_importance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsNewRoutedFromImportance"
    )

    ignored_routing_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("IgnoredRoutingRuleInfo"))),
        graphql_name="ignoredRoutingRules",
    )


class AuditLogEntryConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AuditLogEntryEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class AuditLogEntryEdge(sgqlc.types.Type):
    """A Relay edge containing a `AuditLogEntry` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("AuditLogEntry", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class AuthorRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "username", "email")
    name = sgqlc.types.Field(String, graphql_name="name")

    username = sgqlc.types.Field(String, graphql_name="username")

    email = sgqlc.types.Field(String, graphql_name="email")


class AuthorizationGroupOutput(sgqlc.types.Type):
    """Authorization group used to configure access and permissions for
    users.
    """

    __schema__ = schema
    __field_names__ = (
        "name",
        "roles",
        "version",
        "is_managed",
        "label",
        "description",
        "users",
        "domain_restrictions",
        "connection_restrictions",
        "sso_group",
        "source",
        "is_membership_managed",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Unique to the account, human-readable name (for use in code/policy
    reference).
    """

    roles = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("RoleOutput")), graphql_name="roles"
    )
    """List of roles that are assigned to this group."""

    version = sgqlc.types.Field(String, graphql_name="version")
    """Version of the permissions definitions the group is designed for,
    ex: 2022-03-17. Defaults to current.
    """

    is_managed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isManaged")
    """Indicates if this group is managed by Monte Carlo or through an
    authorization provider, such as SCIM. If so, changes to the group
    are restricted. See the source for details.
    """

    label = sgqlc.types.Field(String, graphql_name="label")
    """UI/user-friendly display name, ex: Data Consumers"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description/help text to help users understand the purpose of the
    group
    """

    users = sgqlc.types.Field(sgqlc.types.list_of("AuthUser"), graphql_name="users")
    """List of users  who are members of the group."""

    domain_restrictions = sgqlc.types.Field(
        sgqlc.types.list_of("DomainRestriction"), graphql_name="domainRestrictions"
    )
    """List of domains this group is limited to."""

    connection_restrictions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("ConnectionRestriction"))),
        graphql_name="connectionRestrictions",
    )
    """List of connections this group is limited to."""

    sso_group = sgqlc.types.Field(String, graphql_name="ssoGroup")
    """SSO group name to map this authorization group to"""

    source = sgqlc.types.Field(
        sgqlc.types.non_null(AuthorizationGroupSource), graphql_name="source"
    )
    """The source or provider of this authorization group."""

    is_membership_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isMembershipManaged"
    )
    """Indicates if the membership of this group is managed through an
    authorization provider or SSO group. If true, membership changes
    can only be made through that source.
    """


class AuthorizationProvisioningOutput(sgqlc.types.Type):
    """Authorization Provisioning configuration, used for provisioning
    users and groups.
    """

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "enabled",
        "provider_name",
        "default_domains",
        "default_roles",
        "base_endpoint",
        "last_updated_on",
        "last_update_user",
        "created_by",
        "created_on",
        "schema",
        "audit_logs",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the auth provisioning model."""

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Is this Authorization Provisioning configuration enabled."""

    provider_name = sgqlc.types.Field(String, graphql_name="providerName")
    """Short text to describe the provider."""

    default_domains = sgqlc.types.Field(
        sgqlc.types.list_of("DomainRestriction"), graphql_name="defaultDomains"
    )
    """List of default domains for auth groups created by this
    configuration.
    """

    default_roles = sgqlc.types.Field(
        sgqlc.types.list_of("RoleOutput"), graphql_name="defaultRoles"
    )
    """List of default roles that are assigned to auth groups created by
    this configuration.
    """

    base_endpoint = sgqlc.types.Field(String, graphql_name="baseEndpoint")
    """Base endpoint used by this auth provisioning."""

    last_updated_on = sgqlc.types.Field(DateTime, graphql_name="lastUpdatedOn")
    """Timestamp when this configuration was last modified."""

    last_update_user = sgqlc.types.Field("AuthUser", graphql_name="lastUpdateUser")
    """User that last updated this configuration."""

    created_by = sgqlc.types.Field("AuthUser", graphql_name="createdBy")
    """User that created this configuration."""

    created_on = sgqlc.types.Field(DateTime, graphql_name="createdOn")
    """Timestamp when this configuration was created."""

    schema = sgqlc.types.Field(String, graphql_name="schema")
    """Schema version for this auth provisioning configuration."""

    audit_logs = sgqlc.types.Field(
        AuditLogEntryConnection,
        graphql_name="auditLogs",
        args=sgqlc.types.ArgDict(
            (
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "timestamp__lt",
                    sgqlc.types.Arg(DateTime, graphql_name="timestamp_Lt", default=None),
                ),
            )
        ),
    )
    """Get usage audit logs

    Arguments:

    * `start_time` (`DateTime`): Start time to fetch audit logs.
      Defaults to current time - 30 days
    * `end_time` (`DateTime`): End time for fetching audit logs.
      Defaults to current time.
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `timestamp__lt` (`DateTime`)None
    """


class AvailableFilter(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("filter_name", "values")
    filter_name = sgqlc.types.Field(PullRequestFilterName, graphql_name="filterName")
    """Name of the filter"""

    values = sgqlc.types.Field(
        sgqlc.types.list_of("AvailableFilterAggregatedValue"), graphql_name="values"
    )
    """Values and counts of the filter"""


class AvailableFilterAggregatedValue(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value", "count")
    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """Value of the filter"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Count of the filter value"""


class AwsAgentInfraDetailsResult(sgqlc.types.Type):
    """Infrastructure information for an AWS Agent."""

    __schema__ = schema
    __field_names__ = ("template", "parameters")
    template = sgqlc.types.Field(sgqlc.types.non_null(GenericScalar), graphql_name="template")
    """The CloudFormation template, in YAML format"""

    parameters = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(GenericScalar)), graphql_name="parameters"
    )
    """The current template parameters."""


class AwsAgentLogsQueryResult(sgqlc.types.Type):
    """The result for a CloudWatch query, includes events and status."""

    __schema__ = schema
    __field_names__ = ("status", "events")
    status = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="status")
    """The status of the query, for example Running or Complete"""

    events = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(GenericScalar)), graphql_name="events"
    )
    """The log events."""


class AwsAgentLogsStopQueryResult(sgqlc.types.Type):
    """The result for stop_query."""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """Indicates if the query was successfully stopped"""


class AwsAgentStartLogsQueryResult(sgqlc.types.Type):
    """The result for start_query including the query ID."""

    __schema__ = schema
    __field_names__ = ("query_id",)
    query_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="queryId")
    """The ID for the started query"""


class AwsAgentUpgradeLogEntry(sgqlc.types.Type):
    """An upgrade log entry from an AWS agent."""

    __schema__ = schema
    __field_names__ = (
        "timestamp",
        "logical_resource_id",
        "resource_status",
        "resource_status_reason",
        "resource_type",
    )
    timestamp = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timestamp")
    """Timestamp for the log entry."""

    logical_resource_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="logicalResourceId"
    )
    """Resource ID."""

    resource_status = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="resourceStatus")
    """Resource status, for example: 'UPDATE_COMPLETE'."""

    resource_status_reason = sgqlc.types.Field(String, graphql_name="resourceStatusReason")
    """Reason for the status, for example: 'User Initiated'."""

    resource_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="resourceType")
    """Resource type, for example: 'AWS::Lambda::Function'."""


class AwsInformation(sgqlc.types.Type):
    """AWS information"""

    __schema__ = schema
    __field_names__ = (
        "account_id",
        "region",
        "secondary_region",
        "is_secondary",
        "env_configuration",
    )
    account_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accountId")
    """AWS Account ID"""

    region = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="region")
    """AWS Region"""

    secondary_region = sgqlc.types.Field(String, graphql_name="secondaryRegion")
    """AWS Secondary Region"""

    is_secondary = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSecondary")
    """Is this the Secondary Region?"""

    env_configuration = sgqlc.types.Field(
        sgqlc.types.non_null(AwsEnvConfiguration), graphql_name="envConfiguration"
    )
    """Active AWS Environment Configuration"""


class AwsPrivateLinkDetails(sgqlc.types.Type):
    """AWS Private Link information"""

    __schema__ = schema
    __field_names__ = ("account_id", "mcd_principal", "regions")
    account_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accountId")
    """AWS Account ID"""

    mcd_principal = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcdPrincipal")
    """MCD Principal"""

    regions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AwsPrivateLinkRegionDetails")),
        graphql_name="regions",
    )
    """List of AWS Private Link regions"""


class AwsPrivateLinkRegionDetails(sgqlc.types.Type):
    """AWS Private Link region information"""

    __schema__ = schema
    __field_names__ = (
        "region",
        "connection_vpc_id",
        "data_store_vpc_endpoint_id",
        "agent_vpc_endpoint_id",
    )
    region = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="region")
    """AWS Region"""

    connection_vpc_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="connectionVpcId"
    )
    """Connection VPC ID"""

    data_store_vpc_endpoint_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="dataStoreVpcEndpointId"
    )
    """Data Store VPC Endpoint ID"""

    agent_vpc_endpoint_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="agentVpcEndpointId"
    )
    """Agent VPC Endpoint ID"""


class AzureAgentCleanupTasks(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted_instances",)
    deleted_instances = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="deletedInstances"
    )
    """Number of deleted tasks"""


class AzureAgentTasksSummary(sgqlc.types.Type):
    """Durable Functions tasks information for an Azure Agent."""

    __schema__ = schema
    __field_names__ = ("pending_instances", "completed_instances")
    pending_instances = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="pendingInstances"
    )
    """Number of pending tasks."""

    completed_instances = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="completedInstances"
    )
    """Number of completed tasks"""


class AzureDevOpsIntegrationOutput(sgqlc.types.Type):
    """Output type for Azure DevOps integration."""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "organization",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """A short name to identify the integration"""

    organization = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="organization")
    """Azure DevOps organization name"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the integration"""


class AzureDevOpsProjectOutput(sgqlc.types.Type):
    """Output type for Azure DevOps project."""

    __schema__ = schema
    __field_names__ = ("id", "name", "description")
    id = sgqlc.types.Field(String, graphql_name="id")
    """Project ID"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Project name"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Project description"""


class AzureDevOpsWorkItemOutput(sgqlc.types.Type):
    """Output type for Azure DevOps work item operations."""

    __schema__ = schema
    __field_names__ = (
        "work_item_id",
        "alert_id",
        "integration_id",
        "work_item_url",
        "work_item_type",
        "project",
        "created_by_email",
        "created_at",
    )
    work_item_id = sgqlc.types.Field(String, graphql_name="workItemId")
    """Work item ID in Azure DevOps"""

    alert_id = sgqlc.types.Field(UUID, graphql_name="alertId")
    """Alert/incident UUID"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Integration UUID"""

    work_item_url = sgqlc.types.Field(String, graphql_name="workItemUrl")
    """URL to the work item in Azure DevOps"""

    work_item_type = sgqlc.types.Field(String, graphql_name="workItemType")
    """Type of work item (Bug, Task, User Story)"""

    project = sgqlc.types.Field(String, graphql_name="project")
    """Project name"""

    created_by_email = sgqlc.types.Field(String, graphql_name="createdByEmail")
    """Email of user who created the work item"""

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """When the work item was created"""


class AzureDevOpsWorkItemTypeOutput(sgqlc.types.Type):
    """Output type for Azure DevOps work item type."""

    __schema__ = schema
    __field_names__ = ("name", "description")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Work item type name (e.g., Bug, Task, User Story)"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Work item type description"""


class AzureDevopsBasicAuthCredentials(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("access_token",)
    access_token = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accessToken")
    """Obfuscated access token"""


class AzureDevopsInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "organization_name",
        "installed_by",
        "basic_auth_credentials",
        "oauth_credentials",
        "display_name",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="uuid")

    organization_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="organizationName"
    )
    """Azure DevOps organization name"""

    installed_by = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="installedBy")
    """Installed by user email"""

    basic_auth_credentials = sgqlc.types.Field(
        AzureDevopsBasicAuthCredentials, graphql_name="basicAuthCredentials"
    )

    oauth_credentials = sgqlc.types.Field(
        "AzureDevopsOauthCredentials", graphql_name="oauthCredentials"
    )

    display_name = sgqlc.types.Field(String, graphql_name="displayName")


class AzureDevopsInstallationListItem(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "organization_name", "installed_by", "display_name")
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Internal Github installation uuid"""

    organization_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="organizationName"
    )
    """Azure DevOps organization name"""

    installed_by = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="installedBy")
    """Installed by user email"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")


class AzureDevopsInstallations(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("installations",)
    installations = sgqlc.types.Field(
        sgqlc.types.list_of(AzureDevopsInstallationListItem), graphql_name="installations"
    )


class AzureDevopsOauthCredentials(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tenant_id", "client_id", "client_secret")
    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")

    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")

    client_secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientSecret")
    """Obfuscated client secret"""


class AzureDevopsOrganization(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "projects", "repositories", "selections")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    projects = sgqlc.types.Field(sgqlc.types.list_of("AzureDevopsProject"), graphql_name="projects")

    repositories = sgqlc.types.Field(
        sgqlc.types.list_of("AzureDevopsRepository"), graphql_name="repositories"
    )

    selections = sgqlc.types.Field(
        sgqlc.types.list_of("AzureDevopsSourceSelection"), graphql_name="selections"
    )


class AzureDevopsProject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name", "repositories")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    repositories = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("AzureDevopsRepository")),
        graphql_name="repositories",
    )


class AzureDevopsRepository(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name", "project")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    project = sgqlc.types.Field(sgqlc.types.non_null(AzureDevopsProject), graphql_name="project")


class AzureDevopsSourceSelection(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("project_id", "repository_id")
    project_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="projectId")

    repository_id = sgqlc.types.Field(String, graphql_name="repositoryId")


class AzureInformation(sgqlc.types.Type):
    """Azure information"""

    __schema__ = schema
    __field_names__ = ("subscription_id", "subscription_name", "primary_region", "secondary_region")
    subscription_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="subscriptionId")
    """Azure Subscription ID"""

    subscription_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="subscriptionName"
    )
    """Azure Subscription Name"""

    primary_region = sgqlc.types.Field(String, graphql_name="primaryRegion")
    """Azure Region"""

    secondary_region = sgqlc.types.Field(String, graphql_name="secondaryRegion")
    """Azure Secondary Region"""


class BiContainer(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "deleted_at",
        "account",
        "uuid",
        "data_collector",
        "type",
        "name",
        "connections",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    data_collector = sgqlc.types.Field("DataCollector", graphql_name="dataCollector")

    type = sgqlc.types.Field(sgqlc.types.non_null(BiContainerModelType), graphql_name="type")

    name = sgqlc.types.Field(String, graphql_name="name")

    connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Connection"))),
        graphql_name="connections",
    )


class BiLineage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "workbook_id",
        "friendly_name",
        "content_url",
        "owner_id",
        "project_id",
        "project_name",
        "created",
        "updated",
        "total_views",
        "workbook_creators",
        "view_id",
        "category",
        "mcon",
        "name",
        "display_name",
    )
    workbook_id = sgqlc.types.Field(String, graphql_name="workbookId")

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")

    content_url = sgqlc.types.Field(String, graphql_name="contentUrl")

    owner_id = sgqlc.types.Field(String, graphql_name="ownerId")

    project_id = sgqlc.types.Field(String, graphql_name="projectId")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    created = sgqlc.types.Field(DateTime, graphql_name="created")

    updated = sgqlc.types.Field(DateTime, graphql_name="updated")

    total_views = sgqlc.types.Field(Int, graphql_name="totalViews")

    workbook_creators = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="workbookCreators"
    )

    view_id = sgqlc.types.Field(String, graphql_name="viewId")

    category = sgqlc.types.Field(String, graphql_name="category")
    """Node type"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Monte Carlo object name"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Object name (table name, report name, etc)"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Friendly display name"""


class BiMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "owner",
        "site",
        "uri",
        "sheets",
        "embedded_datasources",
        "upstream_data_quality_warnings",
        "view_path",
        "workbook_id",
        "workbook_name",
        "view_id",
        "luid",
        "name",
        "is_certified",
        "has_extracts",
        "has_active_warning",
        "has_user_reference",
        "contains_unsupported_custom_sql",
        "extract_last_refresh_time",
        "container_name",
        "container_type",
        "dashboards",
        "model_name",
        "source_file",
        "view_name",
        "connection_name",
        "lookml_model_id",
        "explore_id",
        "explore_name",
        "query",
        "is_deleted",
        "user_id",
        "hidden",
        "deleted_at",
        "last_accessed_at",
        "last_viewed_at",
        "description",
        "favorite_count",
        "view_count",
        "preferred_viewer",
        "readonly",
        "refresh_interval",
        "load_configuration",
        "edit_uri",
        "look_ids",
        "looker_dashboard_tiles",
        "importance_score",
        "dashboard_folder",
        "avg_daily_views_last30_days",
        "total_views_since_creation",
        "model_id",
        "dashboard",
        "chart_title",
        "user_emails",
        "reason",
        "is_manual",
        "aggregation",
        "date_range",
        "workspace",
        "created_by",
        "modified_at",
        "modified_by",
        "report_type",
        "tiles",
        "workbook",
        "url",
        "email",
        "org",
        "kind",
        "project_name",
        "creation_time",
        "created_at",
    )
    owner = sgqlc.types.Field("OwnerRef", graphql_name="owner")

    site = sgqlc.types.Field("SiteRef", graphql_name="site")

    uri = sgqlc.types.Field(String, graphql_name="uri")

    sheets = sgqlc.types.Field(sgqlc.types.list_of("SheetDashboardRef"), graphql_name="sheets")

    embedded_datasources = sgqlc.types.Field(
        sgqlc.types.list_of("NameRef"), graphql_name="embeddedDatasources"
    )

    upstream_data_quality_warnings = sgqlc.types.Field(
        sgqlc.types.list_of("DataQualityWarningsRef"), graphql_name="upstreamDataQualityWarnings"
    )

    view_path = sgqlc.types.Field(String, graphql_name="viewPath")

    workbook_id = sgqlc.types.Field(String, graphql_name="workbookId")

    workbook_name = sgqlc.types.Field(String, graphql_name="workbookName")

    view_id = sgqlc.types.Field(String, graphql_name="viewId")

    luid = sgqlc.types.Field(String, graphql_name="luid")

    name = sgqlc.types.Field(String, graphql_name="name")

    is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified")

    has_extracts = sgqlc.types.Field(Boolean, graphql_name="hasExtracts")

    has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning")

    has_user_reference = sgqlc.types.Field(Boolean, graphql_name="hasUserReference")

    contains_unsupported_custom_sql = sgqlc.types.Field(
        Boolean, graphql_name="containsUnsupportedCustomSql"
    )

    extract_last_refresh_time = sgqlc.types.Field(String, graphql_name="extractLastRefreshTime")

    container_name = sgqlc.types.Field(String, graphql_name="containerName")

    container_type = sgqlc.types.Field(String, graphql_name="containerType")

    dashboards = sgqlc.types.Field(
        sgqlc.types.list_of("SheetDashboardRef"), graphql_name="dashboards"
    )

    model_name = sgqlc.types.Field(String, graphql_name="modelName")

    source_file = sgqlc.types.Field(String, graphql_name="sourceFile")

    view_name = sgqlc.types.Field(String, graphql_name="viewName")

    connection_name = sgqlc.types.Field(String, graphql_name="connectionName")

    lookml_model_id = sgqlc.types.Field(String, graphql_name="lookmlModelId")

    explore_id = sgqlc.types.Field(String, graphql_name="exploreId")

    explore_name = sgqlc.types.Field(String, graphql_name="exploreName")

    query = sgqlc.types.Field("QueryRef", graphql_name="query")

    is_deleted = sgqlc.types.Field(Boolean, graphql_name="isDeleted")

    user_id = sgqlc.types.Field(String, graphql_name="userId")

    hidden = sgqlc.types.Field(String, graphql_name="hidden")

    deleted_at = sgqlc.types.Field(String, graphql_name="deletedAt")

    last_accessed_at = sgqlc.types.Field(String, graphql_name="lastAccessedAt")

    last_viewed_at = sgqlc.types.Field(String, graphql_name="lastViewedAt")

    description = sgqlc.types.Field(String, graphql_name="description")

    favorite_count = sgqlc.types.Field(Int, graphql_name="favoriteCount")

    view_count = sgqlc.types.Field(Int, graphql_name="viewCount")

    preferred_viewer = sgqlc.types.Field(String, graphql_name="preferredViewer")

    readonly = sgqlc.types.Field(Boolean, graphql_name="readonly")

    refresh_interval = sgqlc.types.Field(String, graphql_name="refreshInterval")

    load_configuration = sgqlc.types.Field(String, graphql_name="loadConfiguration")

    edit_uri = sgqlc.types.Field(String, graphql_name="editUri")

    look_ids = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="lookIds")

    looker_dashboard_tiles = sgqlc.types.Field(
        sgqlc.types.list_of("LookerDashboardTileRef"), graphql_name="lookerDashboardTiles"
    )

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")

    dashboard_folder = sgqlc.types.Field(String, graphql_name="dashboardFolder")

    avg_daily_views_last30_days = sgqlc.types.Field(Float, graphql_name="avgDailyViewsLast30Days")

    total_views_since_creation = sgqlc.types.Field(Int, graphql_name="totalViewsSinceCreation")

    model_id = sgqlc.types.Field(String, graphql_name="modelId")

    dashboard = sgqlc.types.Field("SheetDashboardRef", graphql_name="dashboard")

    chart_title = sgqlc.types.Field(String, graphql_name="chartTitle")

    user_emails = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="userEmails")

    reason = sgqlc.types.Field(String, graphql_name="reason")

    is_manual = sgqlc.types.Field(String, graphql_name="isManual")

    aggregation = sgqlc.types.Field(String, graphql_name="aggregation")

    date_range = sgqlc.types.Field(String, graphql_name="dateRange")

    workspace = sgqlc.types.Field("PowerBIWorkSpaceRef", graphql_name="workspace")

    created_by = sgqlc.types.Field(String, graphql_name="createdBy")

    modified_at = sgqlc.types.Field(String, graphql_name="modifiedAt")

    modified_by = sgqlc.types.Field(String, graphql_name="modifiedBy")

    report_type = sgqlc.types.Field(String, graphql_name="reportType")

    tiles = sgqlc.types.Field(sgqlc.types.list_of("PowerBIDashboardTileRef"), graphql_name="tiles")

    workbook = sgqlc.types.Field(String, graphql_name="workbook")

    url = sgqlc.types.Field(String, graphql_name="url")

    email = sgqlc.types.Field(String, graphql_name="email")

    org = sgqlc.types.Field(String, graphql_name="org")

    kind = sgqlc.types.Field(String, graphql_name="kind")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    creation_time = sgqlc.types.Field(String, graphql_name="creationTime")

    created_at = sgqlc.types.Field(String, graphql_name="createdAt")


class BiWarehouseSources(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("warehouse_resource_id", "warehouse_resource_type", "bi_warehouse_id")
    warehouse_resource_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="warehouseResourceId"
    )
    """Warehouse resource ID. This is a Monte Carlo ID"""

    warehouse_resource_type = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="warehouseResourceType"
    )
    """Warehouse type. Examples: snowflake, redshift, etc."""

    bi_warehouse_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="biWarehouseId")
    """The warehouse ID in the BI instance of the customer. This is an ID
    in the customer ID space and is not a Monte Carlo ID.
    """


class BigQueryProject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("full_project_id", "friendly_name")
    full_project_id = sgqlc.types.Field(String, graphql_name="fullProjectId")

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")


class BillingContractInvoice(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "start_time",
        "end_time",
        "tier_name",
        "total",
        "status",
        "commit_consumed",
        "items",
    )
    id = sgqlc.types.Field(String, graphql_name="id")
    """The id of the invoice"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """The start of the invoice period"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """The end of the invoice period"""

    tier_name = sgqlc.types.Field(String, graphql_name="tierName")
    """The name of the current tier"""

    total = sgqlc.types.Field(Int, graphql_name="total")
    """The total cost minus credits"""

    status = sgqlc.types.Field(BillingInvoiceStatus, graphql_name="status")
    """The status of the invoice"""

    commit_consumed = sgqlc.types.Field(Int, graphql_name="commitConsumed")
    """Money subtracted from commits"""

    items = sgqlc.types.Field(
        sgqlc.types.list_of("BillingContractInvoiceItem"), graphql_name="items"
    )
    """Products charged in the invoice"""


class BillingContractInvoiceItem(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("credits", "rate")
    credits = sgqlc.types.Field(Int, graphql_name="credits")
    """The number of credits used."""

    rate = sgqlc.types.Field(Float, graphql_name="rate")
    """The rate at which credits were used."""


class BillingContractInvoiceResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("invoices",)
    invoices = sgqlc.types.Field(
        sgqlc.types.list_of(BillingContractInvoice), graphql_name="invoices"
    )
    """List of contract invoices for the account"""


class BillingCreditGrant(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "name",
        "start_time",
        "end_time",
        "amount_paid",
        "amount_remaining",
        "quantity_remaining",
        "currency",
    )
    id = sgqlc.types.Field(String, graphql_name="id")
    """The id of the credit grant"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Description of the credit"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """The starting time when the credit is valid for use"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """The time that the credit expires"""

    amount_paid = sgqlc.types.Field(Int, graphql_name="amountPaid")
    """The amount paid"""

    amount_remaining = sgqlc.types.Field(Int, graphql_name="amountRemaining")
    """The amount of credit remaining"""

    quantity_remaining = sgqlc.types.Field(Int, graphql_name="quantityRemaining")
    """Quantity remaining calculated from amount_remaining."""

    currency = sgqlc.types.Field(String, graphql_name="currency")
    """The unit of the credit. Currently only `USD (cents)` is supported."""


class BillingCreditGrantResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("credit_grants", "page_info")
    credit_grants = sgqlc.types.Field(
        sgqlc.types.list_of(BillingCreditGrant), graphql_name="creditGrants"
    )
    """List of credit grants for the account"""

    page_info = sgqlc.types.Field("NextPageInfo", graphql_name="pageInfo")
    """Data necessary to paginate the list of credit grants"""


class BillingInvoice(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "start_time",
        "end_time",
        "plan_name",
        "total",
        "currency",
        "status",
        "products",
    )
    id = sgqlc.types.Field(String, graphql_name="id")
    """The id of the invoice"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """The start of the invoice period"""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """The end of the invoice period"""

    plan_name = sgqlc.types.Field(String, graphql_name="planName")
    """The name of the plan"""

    total = sgqlc.types.Field(Int, graphql_name="total")
    """The total cost minus credits"""

    currency = sgqlc.types.Field(String, graphql_name="currency")
    """The currency of the total. Currently only `USD (cents)` is
    supported.
    """

    status = sgqlc.types.Field(BillingInvoiceStatus, graphql_name="status")
    """The status of the invoice"""

    products = sgqlc.types.Field(
        sgqlc.types.list_of("BillingInvoiceProduct"), graphql_name="products"
    )
    """Products charged in the invoice"""


class BillingInvoiceProduct(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "charges")
    name = sgqlc.types.Field(String, graphql_name="name")
    """The name of the product"""

    charges = sgqlc.types.Field(
        sgqlc.types.list_of("BillingInvoiceProductCharge"), graphql_name="charges"
    )
    """Charges for the product"""


class BillingInvoiceProductCharge(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("quantity", "commit_rate", "on_demand_rate")
    quantity = sgqlc.types.Field(Int, graphql_name="quantity")
    """The quantity of product charged"""

    commit_rate = sgqlc.types.Field(Int, graphql_name="commitRate")
    """Value only exists for commit plans."""

    on_demand_rate = sgqlc.types.Field(Int, graphql_name="onDemandRate")
    """Value exists for both commit and on-demand plans."""


class BillingInvoiceResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("invoices", "page_info")
    invoices = sgqlc.types.Field(sgqlc.types.list_of(BillingInvoice), graphql_name="invoices")
    """List of invoices for the account"""

    page_info = sgqlc.types.Field("NextPageInfo", graphql_name="pageInfo")
    """Data necessary to paginate the list of invoices"""


class BillingMonitorUsage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "date",
        "table_monitor_credits",
        "metric_monitor_credits",
        "validation_monitor_credits",
        "comparison_monitor_credits",
        "custom_sql_monitor_credits",
        "performance_monitor_credits",
        "json_schema_monitor_credits",
        "metric_legacy_monitor_credits",
        "freshness_rule_monitor_credits",
        "volume_rule_monitor_credits",
        "metric_comparison_monitor_credits",
    )
    date = sgqlc.types.Field(Date, graphql_name="date")
    """The date for this data point"""

    table_monitor_credits = sgqlc.types.Field(Float, graphql_name="tableMonitorCredits")
    """Credits used by table monitors"""

    metric_monitor_credits = sgqlc.types.Field(Float, graphql_name="metricMonitorCredits")
    """Credits used by metric monitors"""

    validation_monitor_credits = sgqlc.types.Field(Float, graphql_name="validationMonitorCredits")
    """Credits used by validation monitors"""

    comparison_monitor_credits = sgqlc.types.Field(Float, graphql_name="comparisonMonitorCredits")
    """Credits used by comparison monitors"""

    custom_sql_monitor_credits = sgqlc.types.Field(Float, graphql_name="customSqlMonitorCredits")
    """Credits used by custom SQL monitors"""

    performance_monitor_credits = sgqlc.types.Field(Float, graphql_name="performanceMonitorCredits")
    """Credits used by performance monitors"""

    json_schema_monitor_credits = sgqlc.types.Field(Float, graphql_name="jsonSchemaMonitorCredits")
    """Credits used by JSON schema monitors"""

    metric_legacy_monitor_credits = sgqlc.types.Field(
        Float, graphql_name="metricLegacyMonitorCredits"
    )
    """Credits used by metric_legacy monitors"""

    freshness_rule_monitor_credits = sgqlc.types.Field(
        Float, graphql_name="freshnessRuleMonitorCredits"
    )
    """Credits used by freshness rule monitors"""

    volume_rule_monitor_credits = sgqlc.types.Field(Float, graphql_name="volumeRuleMonitorCredits")
    """Credits used by volume rule monitors"""

    metric_comparison_monitor_credits = sgqlc.types.Field(
        Float, graphql_name="metricComparisonMonitorCredits"
    )
    """Credits used by metric comparison monitors"""


class BillingMonitorUsageResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("usages",)
    usages = sgqlc.types.Field(sgqlc.types.list_of(BillingMonitorUsage), graphql_name="usages")
    """List of daily monitor usage data points."""


class BulkAddMonitorDataQualityDimension(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class BulkAddMonitorTags(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class BulkCreateOrUpdateObjectProperties(sgqlc.types.Type):
    """Create or update a list of properties (tags) for objects (e.g.
    tables, fields, etc.)
    """

    __schema__ = schema
    __field_names__ = ("object_properties",)
    object_properties = sgqlc.types.Field(
        sgqlc.types.list_of("ObjectProperty"), graphql_name="objectProperties"
    )
    """List of properties created or updated"""


class BulkSetEtlJobGeneratesAlerts(sgqlc.types.Type):
    """Set whether a set of ETL jobs (like an Airflow DAG) generates
    alerts or not
    """

    __schema__ = schema
    __field_names__ = ("updated_jobs",)
    updated_jobs = sgqlc.types.Field(Int, graphql_name="updatedJobs")
    """Number of jobs updated"""


class BulkUpdateAlerts(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class BulkUpdateIncidents(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class CaasCollectionNodeParameters(sgqlc.types.Type):
    """Node parameters"""

    __schema__ = schema
    __field_names__ = ("parameters",)
    parameters = sgqlc.types.Field(sgqlc.types.non_null(GenericScalar), graphql_name="parameters")
    """Node parameters"""


class CaasLinkCollectionResources(sgqlc.types.Type):
    """Links a pre-provisioned node and data-store to the specified DC.
    Only non-active DCs with template_variant=aether are supported.
    """

    __schema__ = schema
    __field_names__ = ("dc",)
    dc = sgqlc.types.Field("DataCollector", graphql_name="dc")
    """The data collector that was updated"""


class CaasUpdateCollectionNodeEnv(sgqlc.types.Type):
    """Updates the environment variables for the collection node
    associated to the specified DC
    """

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CaasUpdateCollectionNodeParameters(sgqlc.types.Type):
    """Updates the parameters for the collection node associated to the
    specified DC
    """

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CaasUpdateCollectionNodeVersion(sgqlc.types.Type):
    """Updates the collection node associated to the specified DC to the
    specified version.If no version is provided, the node is upgraded
    to latest version.
    """

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CaasUpdateCollectionStorageEncryption(sgqlc.types.Type):
    """Sets the collection storage encryption"""

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CaasUpdateCollectionStorageLink(sgqlc.types.Type):
    """If there's an agent associated to the service, it makes sure the
    link to the CaaS storage is deleted.
    """

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CaasUpdateCollectionStorageParameters(sgqlc.types.Type):
    """Updates the parameters for the collection storage associated to
    the specified DC
    """

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CaasUpdateCollectionStorageVersion(sgqlc.types.Type):
    """Updates the collection storage template version associated to the
    specified DC.
    """

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class CatalogMapping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("from_name", "to_name")
    from_name = sgqlc.types.Field(String, graphql_name="fromName")
    """From catalog object name."""

    to_name = sgqlc.types.Field(String, graphql_name="toName")
    """To catalog object name."""


class CatalogMappings(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("database_mappings",)
    database_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(CatalogMapping), graphql_name="databaseMappings"
    )


class CatalogNavNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon_id", "display_name", "object_type", "path", "may_have_children")
    mcon_id = sgqlc.types.Field(String, graphql_name="mconId")
    """MCON ID of the object represented by this node."""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """User-friendly display name of the catalog object."""

    object_type = sgqlc.types.Field(String, graphql_name="objectType")
    """The catalog object's type."""

    path = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="path")
    """Object's hierarchy as list of ancestors plus self, if applicable."""

    may_have_children = sgqlc.types.Field(Boolean, graphql_name="mayHaveChildren")
    """Whether or not the node may have children. (Does not indicate if
    it actually does.)
    """


class CatalogNavResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes", "has_next_page", "next_page_offset", "group_object_type")
    nodes = sgqlc.types.Field(sgqlc.types.list_of(CatalogNavNode), graphql_name="nodes")
    """Nodes for current nav page."""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """If there are more nodes."""

    next_page_offset = sgqlc.types.Field(Int, graphql_name="nextPageOffset")
    """Where to start for next page, if next page exists."""

    group_object_type = sgqlc.types.Field(String, graphql_name="groupObjectType")
    """Object type of the group, when grouping by type."""


class CatalogObjectMetadataConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CatalogObjectMetadataEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CatalogObjectMetadataEdge(sgqlc.types.Type):
    """A Relay edge containing a `CatalogObjectMetadata` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CatalogObjectMetadata", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CategorizedSearchResponse(sgqlc.types.Type):
    """List of tables for dynamic schedule"""

    __schema__ = schema
    __field_names__ = ("total_hits", "results")
    total_hits = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalHits")
    """Number of results"""

    results = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CategorizedSearchResult")), graphql_name="results"
    )
    """List of matching results"""


class CategorizedSearchResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "lineage_node_id",
        "object_type",
        "object_id",
        "display_name",
        "parent_mcon",
        "path",
        "project_id",
        "dataset",
        "table_id",
        "properties",
        "resource_id",
        "warehouse_display_name",
        "description",
        "field_type",
        "highlight",
        "highlight_properties",
        "field_names",
        "is_important",
        "importance_score",
        "upstream_resource_ids",
        "bi_parent_name",
        "is_monitored",
        "is_muted",
        "etl_type",
        "supports_data_explorer",
        "dbt_project_name",
        "category",
        "is_dynamic_schedule_supported",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Monte Carlo full identifier for an entity"""

    lineage_node_id = sgqlc.types.Field(String, graphql_name="lineageNodeId")
    """Identifier for lineage nodes. Warning - To be deprecated soon"""

    object_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="objectType")
    """Type of object (e.g. table, view, etc.)"""

    object_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="objectId")
    """Partial identifier (e.g. project:dataset.table)"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Friendly name for entity"""

    parent_mcon = sgqlc.types.Field(String, graphql_name="parentMcon")
    """Identifier for any parents (e.g. field belonging to a table)"""

    path = sgqlc.types.Field(String, graphql_name="path")
    """Path to node"""

    project_id = sgqlc.types.Field(String, graphql_name="projectId")
    """Name of project (database or catalog in some warehouses)"""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Name of dataset (schema in some warehouses)"""

    table_id = sgqlc.types.Field(String, graphql_name="tableId")
    """Name of the table"""

    properties = sgqlc.types.Field(
        sgqlc.types.list_of("SearchResultProperty"), graphql_name="properties"
    )
    """Any attached labels"""

    resource_id = sgqlc.types.Field(String, graphql_name="resourceId")
    """Resource identifier (e.g. warehouse). Warning - To be deprecated
    soon
    """

    warehouse_display_name = sgqlc.types.Field(String, graphql_name="warehouseDisplayName")
    """Name of warehouse"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description of object"""

    field_type = sgqlc.types.Field(String, graphql_name="fieldType")
    """Data type of field. Only populated if object_type=field"""

    highlight = sgqlc.types.Field(
        sgqlc.types.list_of("HighlightSnippets"), graphql_name="highlight"
    )
    """Highlight snippets"""

    highlight_properties = sgqlc.types.Field(
        sgqlc.types.list_of("NestedHighlightSnippets"), graphql_name="highlightProperties"
    )
    """Highlight snippets for object properties"""

    field_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fieldNames")
    """Field names (if object_type=table)"""

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")
    """Whether the table or field is important"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """Importance score for tables"""

    upstream_resource_ids = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="upstreamResourceIds"
    )
    """Upstream resource ids"""

    bi_parent_name = sgqlc.types.Field(String, graphql_name="biParentName")
    """Name of parent resource to BI asset"""

    is_monitored = sgqlc.types.Field(Boolean, graphql_name="isMonitored")
    """Whether the table is monitored"""

    is_muted = sgqlc.types.Field(Boolean, graphql_name="isMuted")
    """Whether the table is muted"""

    etl_type = sgqlc.types.Field(EtlType, graphql_name="etlType")
    """ETL type of the job asset (if object_type=job)"""

    supports_data_explorer = sgqlc.types.Field(Boolean, graphql_name="supportsDataExplorer")
    """Whether the table supports data explorer"""

    dbt_project_name = sgqlc.types.Field(String, graphql_name="dbtProjectName")
    """Name of the dbt project for dbt-job assets"""

    category = sgqlc.types.Field(SearchCategoryEnum, graphql_name="category")
    """Name of the category for the table like: RESOLVED TABLES, ALL
    TABLES etc
    """

    is_dynamic_schedule_supported = sgqlc.types.Field(
        Boolean, graphql_name="isDynamicScheduleSupported"
    )
    """Whether the table is supported for dynamic scheduling"""


class CategoryLabelRank(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_series_uuid", "label", "rank")
    time_series_uuid = sgqlc.types.Field(UUID, graphql_name="timeSeriesUuid")

    label = sgqlc.types.Field(String, graphql_name="label")

    rank = sgqlc.types.Field(Float, graphql_name="rank")


class CircuitBreakerState(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "job_execution_uuid",
        "account_uuid",
        "resource_uuid",
        "custom_rule_uuid",
        "status",
        "log",
    )
    job_execution_uuid = sgqlc.types.Field(UUID, graphql_name="jobExecutionUuid")
    """UUID for the job execution that identifies the circuit breaker run"""

    account_uuid = sgqlc.types.Field(UUID, graphql_name="accountUuid")
    """UUID for the account that owns the rule"""

    resource_uuid = sgqlc.types.Field(UUID, graphql_name="resourceUuid")
    """UUID for the warehouse that owns the rule"""

    custom_rule_uuid = sgqlc.types.Field(UUID, graphql_name="customRuleUuid")
    """UUID for the custom rule that was run as a circuit breaker"""

    status = sgqlc.types.Field(SqlJobCheckpointStatus, graphql_name="status")
    """Status of the circuit breaker run"""

    log = sgqlc.types.Field(JSONString, graphql_name="log")
    """Array of JSON objects containing state for each stage of the job
    execution
    """


class ClassificationCategories(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("label", "description", "examples")
    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")

    description = sgqlc.types.Field(String, graphql_name="description")

    examples = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="examples"
    )


class CleanupCollectorRecordInAccount(sgqlc.types.Type):
    """Deletes an unassociated collector record in the account. This does
    not delete the CloudFormation stack and will not succeed if the
    collector is active and/or associated with a warehouse.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """If the collector record was deleted"""


class CollectionBlockConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CollectionBlockEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CollectionBlockEdge(sgqlc.types.Type):
    """A Relay edge containing a `CollectionBlock` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CollectionBlock", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CollectionDataSet(sgqlc.types.Type):
    """Data set to collect data."""

    __schema__ = schema
    __field_names__ = ("resource_id", "project", "dataset")
    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """The resource UUID of the dataset."""

    project = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="project")
    """Top-level object hierarchy e.g. database, catalog, etc."""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Intermediate object hierarchy e.g. schema, database, etc."""


class CollectionDataSetConnection(sgqlc.types.relay.Connection):
    """Datasets to collect data"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CollectionDataSetEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CollectionDataSetEdge(sgqlc.types.Type):
    """A Relay edge containing a `CollectionDataSet` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(CollectionDataSet, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CollectionDetails(sgqlc.types.Type):
    """Collection platform information"""

    __schema__ = schema
    __field_names__ = (
        "aws_account_id",
        "aws_region",
        "private_link_details",
        "active_node_details",
    )
    aws_account_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="awsAccountId")
    """AWS Account ID"""

    aws_region = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="awsRegion")
    """AWS Region"""

    private_link_details = sgqlc.types.Field(
        "PrivateLinkDetails", graphql_name="privateLinkDetails"
    )
    """Private Link information"""

    active_node_details = sgqlc.types.Field(
        sgqlc.types.list_of(ActiveNodeDetails), graphql_name="activeNodeDetails"
    )
    """List of active nodes"""


class CollectionNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "status", "stack_arn", "assigned_on", "resources")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    status = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionNodeModelStatus), graphql_name="status"
    )
    """Resource status"""

    stack_arn = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="stackArn")
    """ARN of CloudFormation stack"""

    assigned_on = sgqlc.types.Field(DateTime, graphql_name="assignedOn")
    """Timestamp resource was assigned"""

    resources = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="resources")
    """Node resources"""


class CollectionProperties(sgqlc.types.Type):
    """Collection infrastructure properties"""

    __schema__ = schema
    __field_names__ = (
        "cross_account_external_id",
        "customer_account_token",
        "code_bucket",
        "code_version",
        "platform_aws_account_id",
        "docker_image_uri",
        "platform_region_details",
    )
    cross_account_external_id = sgqlc.types.Field(String, graphql_name="crossAccountExternalId")
    """External id for cross account IAM role"""

    customer_account_token = sgqlc.types.Field(String, graphql_name="customerAccountToken")
    """Customer account token (unique per data collector)"""

    code_bucket = sgqlc.types.Field(String, graphql_name="codeBucket")
    """S3 bucket containing data collector code"""

    code_version = sgqlc.types.Field(String, graphql_name="codeVersion")
    """Data collector code version"""

    platform_aws_account_id = sgqlc.types.Field(String, graphql_name="platformAwsAccountId")
    """Monte Carlo AWS account id"""

    docker_image_uri = sgqlc.types.Field(String, graphql_name="dockerImageUri")
    """URI of the docker image for the data collector"""

    platform_region_details = sgqlc.types.Field(
        "PlatformRegionProperties", graphql_name="platformRegionDetails"
    )
    """Region-specific properties"""


class CollectionStatusOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("interval_in_seconds", "interval_crontab", "next_run")
    interval_in_seconds = sgqlc.types.Field(Float, graphql_name="intervalInSeconds")
    """Interval in seconds between data collections"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Interval as cron expressions between data collections"""

    next_run = sgqlc.types.Field(DateTime, graphql_name="nextRun")
    """Date & time of next collection run"""


class CollectionStorage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "status", "stack_arn", "assigned_on", "resources")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    status = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionStorageModelStatus), graphql_name="status"
    )
    """Resource status"""

    stack_arn = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="stackArn")
    """ARN of CloudFormation stack"""

    assigned_on = sgqlc.types.Field(DateTime, graphql_name="assignedOn")
    """Timestamp resource was assigned"""

    resources = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="resources")
    """Storage resources"""


class CollibraDomainSearchResponse(sgqlc.types.Type):
    """Collibra domain search response for table search name"""

    __schema__ = schema
    __field_names__ = (
        "collibra_table_asset_id",
        "collibra_table_asset_domain_id",
        "collibra_schema_asset_id",
        "collibra_database_asset_id",
        "collibra_database_asset_domain_id",
    )
    collibra_table_asset_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="collibraTableAssetId"
    )
    """Collibra table asset ID"""

    collibra_table_asset_domain_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="collibraTableAssetDomainId"
    )
    """Collibra table asset domain ID"""

    collibra_schema_asset_id = sgqlc.types.Field(String, graphql_name="collibraSchemaAssetId")
    """Collibra schema asset ID"""

    collibra_database_asset_id = sgqlc.types.Field(String, graphql_name="collibraDatabaseAssetId")
    """Collibra database asset ID"""

    collibra_database_asset_domain_id = sgqlc.types.Field(
        String, graphql_name="collibraDatabaseAssetDomainId"
    )
    """Collibra database asset domain ID"""


class CollibraIntegrationConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CollibraIntegrationEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CollibraIntegrationEdge(sgqlc.types.Type):
    """A Relay edge containing a `CollibraIntegration` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CollibraIntegration", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CollibraMonitorNoteResponse(sgqlc.types.Type):
    """Collibra monitor note response."""

    __schema__ = schema
    __field_names__ = ("monitor_uuid", "collibra_note")
    monitor_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="monitorUuid")
    """Monitor uuid"""

    collibra_note = sgqlc.types.Field(String, graphql_name="collibraNote")
    """Collibra note"""


class CollibraPingResponse(sgqlc.types.Type):
    """Collibra ping information"""

    __schema__ = schema
    __field_names__ = ("ping",)
    ping = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="ping")
    """True if got response from Collibra using credentials"""


class ColumnLineage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("selected_column", "lineage_sources")
    selected_column = sgqlc.types.Field(String, graphql_name="selectedColumn")
    """The column on the destination table"""

    lineage_sources = sgqlc.types.Field(
        sgqlc.types.list_of("LineageSources"), graphql_name="lineageSources"
    )
    """Direct source lineage of the selected column"""


class ComparableDashboardType(sgqlc.types.Type):
    """Another dashboard that is compatible for comparison"""

    __schema__ = schema
    __field_names__ = ("dashboard_uuid", "shared_time_axis_field_name", "shared_field_names")
    dashboard_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dashboardUuid")

    shared_time_axis_field_name = sgqlc.types.Field(String, graphql_name="sharedTimeAxisFieldName")
    """Shared time axis field name"""

    shared_field_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="sharedFieldNames"
    )
    """Fields shared between dashboards"""


class ComparisonAlertCondition(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "metric",
        "custom_metric",
        "source_field",
        "target_field",
        "type",
        "operator",
        "threshold_value",
        "is_threshold_relative",
    )
    metric = sgqlc.types.Field(String, graphql_name="metric")

    custom_metric = sgqlc.types.Field("CustomComparisonMetric", graphql_name="customMetric")

    source_field = sgqlc.types.Field(String, graphql_name="sourceField")

    target_field = sgqlc.types.Field(String, graphql_name="targetField")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

    operator = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="operator")

    threshold_value = sgqlc.types.Field(Float, graphql_name="thresholdValue")

    is_threshold_relative = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isThresholdRelative"
    )


class ComparisonEvaluationResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("errors", "field_metric_time_series_count", "max_segments")
    errors = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Error"))),
        graphql_name="errors",
    )

    field_metric_time_series_count = sgqlc.types.Field(
        Int, graphql_name="fieldMetricTimeSeriesCount"
    )
    """Number of separate field/metric time series in the query."""

    max_segments = sgqlc.types.Field(Int, graphql_name="maxSegments")
    """Maximum number of allowed segments for the given field and metric
    selection.
    """


class ComparisonMonitorResponseConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("ComparisonMonitorResponseEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class ComparisonMonitorResponseEdge(sgqlc.types.Type):
    """A Relay edge containing a `ComparisonMonitorResponse` and its
    cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("ComparisonMonitorResponse", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class ConditionMatches(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("column", "rows", "sql")
    column = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="column")

    rows = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(Int)), graphql_name="rows")

    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")


class ConfigureAiAgentPrompt(sgqlc.types.Type):
    """Configure or update the context prompt for an AI agent type"""

    __schema__ = schema
    __field_names__ = ("ai_agent", "success")
    ai_agent = sgqlc.types.Field(AiAgent, graphql_name="aiAgent")
    """The configured AI agent"""

    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """Whether the operation succeeded"""


class ConfigureMetadataEvents(sgqlc.types.Type):
    """Configure collection of metadata via S3 events"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class ConfigureQueryLogEvents(sgqlc.types.Type):
    """Configure collection of query logs via S3 events"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class ConnectPlatformServiceToExistingAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("agent_id",)
    agent_id = sgqlc.types.Field(UUID, graphql_name="agentId")
    """The UUID assigned to the new agent."""


class ConnectPlatformServiceToExistingBucket(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_store_id",)
    data_store_id = sgqlc.types.Field(UUID, graphql_name="dataStoreId")
    """The UUID assigned to the data store created from the existing
    bucket.
    """


class ConnectPlatformServiceToLegacyBucket(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dc",)
    dc = sgqlc.types.Field("DataCollector", graphql_name="dc")
    """The data collector that was updated"""


class ConnectedMcons(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("connected_mcons",)
    connected_mcons = sgqlc.types.Field(
        sgqlc.types.list_of("LineageMconNode"), graphql_name="connectedMcons"
    )
    """List of mcons"""


class Connection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "deleted_at",
        "uuid",
        "type",
        "subtype",
        "name",
        "warehouse",
        "bi_container",
        "etl_container",
        "deletion_protection",
        "job_types",
        "streaming_cluster",
        "credentials_s3_key",
        "integration_gateway_credentials_key",
        "data",
        "created_on",
        "updated_on",
        "is_active",
        "disabled_on",
        "dbt_projects",
        "account",
        "connection_identifier",
        "connection_identifiers",
        "job_errors",
        "resolved_connection_type",
        "sql_job_timeout_maximum",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    type = sgqlc.types.Field(sgqlc.types.non_null(ConnectionModelType), graphql_name="type")

    subtype = sgqlc.types.Field(String, graphql_name="subtype")
    """Subtype of a plugin connection"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Connection name"""

    warehouse = sgqlc.types.Field("Warehouse", graphql_name="warehouse")

    bi_container = sgqlc.types.Field(BiContainer, graphql_name="biContainer")

    etl_container = sgqlc.types.Field("EtlContainer", graphql_name="etlContainer")

    deletion_protection = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="deletionProtection"
    )
    """Prevents deletion when enabled."""

    job_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="jobTypes",
    )

    streaming_cluster = sgqlc.types.Field("StreamingCluster", graphql_name="streamingCluster")

    credentials_s3_key = sgqlc.types.Field(String, graphql_name="credentialsS3Key")

    integration_gateway_credentials_key = sgqlc.types.Field(
        String, graphql_name="integrationGatewayCredentialsKey"
    )

    data = sgqlc.types.Field(JSONString, graphql_name="data")

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    updated_on = sgqlc.types.Field(DateTime, graphql_name="updatedOn")

    is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive")

    disabled_on = sgqlc.types.Field(DateTime, graphql_name="disabledOn")

    dbt_projects = sgqlc.types.Field(
        sgqlc.types.non_null("DbtProjectConnection"),
        graphql_name="dbtProjects",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """dbt connection

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    account = sgqlc.types.Field(Account, graphql_name="account")

    connection_identifier = sgqlc.types.Field(
        "ConnectionIdentifier", graphql_name="connectionIdentifier"
    )

    connection_identifiers = sgqlc.types.Field(
        sgqlc.types.list_of("ConnectionIdentifier"), graphql_name="connectionIdentifiers"
    )

    job_errors = sgqlc.types.Field(sgqlc.types.list_of("JobError"), graphql_name="jobErrors")
    """Errors related to the connection"""

    resolved_connection_type = sgqlc.types.Field(String, graphql_name="resolvedConnectionType")
    """Identifies the connection type"""

    sql_job_timeout_maximum = sgqlc.types.Field(Int, graphql_name="sqlJobTimeoutMaximum")
    """The maximum timeout for SQL jobs that can be set for this
    connection
    """


class ConnectionIdentifier(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Connection credential key serving as an identifier"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Value of connection identifier key"""


class ConnectionValidation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("type", "message", "data")
    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")
    """Validation type"""

    message = sgqlc.types.Field(String, graphql_name="message")
    """Message describing the validation"""

    data = sgqlc.types.Field("ConnectionValidationData", graphql_name="data")
    """Metadata for the validation"""


class ConnectionValidationData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("database", "table", "error")
    database = sgqlc.types.Field(String, graphql_name="database")
    """Database name"""

    table = sgqlc.types.Field(String, graphql_name="table")
    """Table identifier"""

    error = sgqlc.types.Field(String, graphql_name="error")
    """Error message"""


class ContractCommit(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name", "start", "expiration", "amount_paid", "amount_remaining")
    id = sgqlc.types.Field(String, graphql_name="id")
    """The id of the commit"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Description of the commit"""

    start = sgqlc.types.Field(DateTime, graphql_name="start")
    """The starting time of the commit"""

    expiration = sgqlc.types.Field(DateTime, graphql_name="expiration")
    """The expiration time of the commit"""

    amount_paid = sgqlc.types.Field(Int, graphql_name="amountPaid")
    """The committed funds paid upfront"""

    amount_remaining = sgqlc.types.Field(Int, graphql_name="amountRemaining")
    """The amount of committed funds remaining"""


class ContractCommitResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("contract_commits",)
    contract_commits = sgqlc.types.Field(
        sgqlc.types.list_of(ContractCommit), graphql_name="contractCommits"
    )
    """List of commits for all contracts"""


class ConversionResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "account_name",
        "account_uuid",
        "has_job_connection",
        "use_cbp_v2",
        "table_monitor_specs",
        "removed_table_monitor_specs",
        "job_routing_rules_specs",
        "unconvertible_routing_rules",
        "unconvertible_monitoring_rules",
        "warnings",
        "warehouse_count",
        "routing_rules_count",
        "monitoring_rules_count",
        "converted_monitor_uuids",
        "monitored_tables_count",
        "selected_tables_count",
        "top_multicovered_mcons_by_monitor_count",
        "mcon_coverage_distribution",
        "top_multicovered_mcons_by_monitor_count_per_alert_condition",
        "mcon_coverage_distribution_per_alert_condition",
        "mcon_coverage_distribution_per_audience_and_alert_condition",
        "multi_covered_mcons_by_audience_alert_condition_count",
        "multi_covered_mcons_by_alert_condition_count",
        "multi_covered_mcons_global_count",
        "sample_covered_not_monitored",
        "sample_monitored_not_covered",
        "mcons_covered_by_table_monitor_audiences",
        "mcons_covered_by_notification_routing_audiences",
        "mcons_covered_by_notification_routing_audiences_excluding_importance",
        "sample_mcons_routing_not_table_monitor",
        "sample_mcons_routing_not_table_monitor_excluding_importance",
        "sample_mcons_table_monitor_not_routing",
        "mcons_new_routed_from_importance",
        "mcons_monitored_from_empty_tag_values",
        "sample_mcons_monitored_from_empty_tag_values",
        "mcons_included_by_unexpanded_regex",
        "mcons_excluded_by_unexpanded_regex",
        "sample_mcons_affected_by_unexpanded_regex",
        "all_unexpanded_regex_patterns",
        "audience_routing_stats",
        "text_output",
        "summary_text",
        "table_monitor_specs_text",
        "job_routing_rules_text",
        "unconvertible_rules_text",
        "warnings_text",
        "validation_errors",
        "full_output_text",
    )
    account_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accountName")

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")

    has_job_connection = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasJobConnection"
    )

    use_cbp_v2 = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="useCbpV2")

    table_monitor_specs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableMonitorSpec"))),
        graphql_name="tableMonitorSpecs",
    )

    removed_table_monitor_specs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableMonitorSpec"))),
        graphql_name="removedTableMonitorSpecs",
    )

    job_routing_rules_specs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("JobRoutingRuleSpec"))),
        graphql_name="jobRoutingRulesSpecs",
    )

    unconvertible_routing_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("RoutingRuleData"))),
        graphql_name="unconvertibleRoutingRules",
    )

    unconvertible_monitoring_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MonitoringRuleData"))),
        graphql_name="unconvertibleMonitoringRules",
    )

    warnings = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="warnings",
    )

    warehouse_count = sgqlc.types.Field(Int, graphql_name="warehouseCount")

    routing_rules_count = sgqlc.types.Field(Int, graphql_name="routingRulesCount")

    monitoring_rules_count = sgqlc.types.Field(Int, graphql_name="monitoringRulesCount")

    converted_monitor_uuids = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
        graphql_name="convertedMonitorUuids",
    )

    monitored_tables_count = sgqlc.types.Field(Int, graphql_name="monitoredTablesCount")

    selected_tables_count = sgqlc.types.Field(Int, graphql_name="selectedTablesCount")

    top_multicovered_mcons_by_monitor_count = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconCountPair"))),
        graphql_name="topMulticoveredMconsByMonitorCount",
    )

    mcon_coverage_distribution = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconsMonitorsCountPair"))),
        graphql_name="mconCoverageDistribution",
    )

    top_multicovered_mcons_by_monitor_count_per_alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null(GenericScalar),
        graphql_name="topMulticoveredMconsByMonitorCountPerAlertCondition",
    )

    mcon_coverage_distribution_per_alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null(GenericScalar),
        graphql_name="mconCoverageDistributionPerAlertCondition",
    )

    mcon_coverage_distribution_per_audience_and_alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null(GenericScalar),
        graphql_name="mconCoverageDistributionPerAudienceAndAlertCondition",
    )

    multi_covered_mcons_by_audience_alert_condition_count = sgqlc.types.Field(
        Int, graphql_name="multiCoveredMconsByAudienceAlertConditionCount"
    )

    multi_covered_mcons_by_alert_condition_count = sgqlc.types.Field(
        Int, graphql_name="multiCoveredMconsByAlertConditionCount"
    )

    multi_covered_mcons_global_count = sgqlc.types.Field(
        Int, graphql_name="multiCoveredMconsGlobalCount"
    )

    sample_covered_not_monitored = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleCoveredNotMonitored",
    )

    sample_monitored_not_covered = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconRuleIdPair"))),
        graphql_name="sampleMonitoredNotCovered",
    )

    mcons_covered_by_table_monitor_audiences = sgqlc.types.Field(
        Int, graphql_name="mconsCoveredByTableMonitorAudiences"
    )

    mcons_covered_by_notification_routing_audiences = sgqlc.types.Field(
        Int, graphql_name="mconsCoveredByNotificationRoutingAudiences"
    )

    mcons_covered_by_notification_routing_audiences_excluding_importance = sgqlc.types.Field(
        Int, graphql_name="mconsCoveredByNotificationRoutingAudiencesExcludingImportance"
    )

    sample_mcons_routing_not_table_monitor = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsRoutingNotTableMonitor",
    )

    sample_mcons_routing_not_table_monitor_excluding_importance = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsRoutingNotTableMonitorExcludingImportance",
    )

    sample_mcons_table_monitor_not_routing = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsTableMonitorNotRouting",
    )

    mcons_new_routed_from_importance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsNewRoutedFromImportance"
    )

    mcons_monitored_from_empty_tag_values = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsMonitoredFromEmptyTagValues"
    )

    sample_mcons_monitored_from_empty_tag_values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsMonitoredFromEmptyTagValues",
    )

    mcons_included_by_unexpanded_regex = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsIncludedByUnexpandedRegex"
    )

    mcons_excluded_by_unexpanded_regex = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="mconsExcludedByUnexpandedRegex"
    )

    sample_mcons_affected_by_unexpanded_regex = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MconMonitorPair"))),
        graphql_name="sampleMconsAffectedByUnexpandedRegex",
    )

    all_unexpanded_regex_patterns = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("UnexpandedRegexPattern"))),
        graphql_name="allUnexpandedRegexPatterns",
    )

    audience_routing_stats = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AudienceRoutingStats))),
        graphql_name="audienceRoutingStats",
    )

    text_output = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="textOutput")

    summary_text = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="summaryText")

    table_monitor_specs_text = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="tableMonitorSpecsText"
    )

    job_routing_rules_text = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="jobRoutingRulesText"
    )

    unconvertible_rules_text = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="unconvertibleRulesText"
    )

    warnings_text = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="warningsText")

    validation_errors = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="validationErrors",
    )

    full_output_text = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="fullOutputText"
    )


class ConvertConfigTemplateToUiMonitors(sgqlc.types.Type):
    """Convert a config template to UI Monitors"""

    __schema__ = schema
    __field_names__ = ("response",)
    response = sgqlc.types.Field("ConvertConfigTemplateToUiMonitorsOutput", graphql_name="response")
    """Exported template"""


class ConvertConfigTemplateToUiMonitorsOutput(sgqlc.types.Type):
    """Convert config template to UI monitors response"""

    __schema__ = schema
    __field_names__ = ("monitors",)
    monitors = sgqlc.types.Field(
        sgqlc.types.list_of("UserDefinedMonitorV2"), graphql_name="monitors"
    )
    """Converted monitors"""


class ConvertUiMonitorsToConfigTemplate(sgqlc.types.Type):
    """Convert a set of monitors to a config template"""

    __schema__ = schema
    __field_names__ = ("response",)
    response = sgqlc.types.Field("ConvertUiMonitorsToConfigTemplateOutput", graphql_name="response")
    """Exported template"""


class ConvertUiMonitorsToConfigTemplateOutput(sgqlc.types.Type):
    """Convert monitors to config template response"""

    __schema__ = schema
    __field_names__ = (
        "monitors",
        "config_template_as_yaml",
        "config_template_as_dict",
        "errors",
        "warnings",
    )
    monitors = sgqlc.types.Field(sgqlc.types.list_of("UserDefinedMonitor"), graphql_name="monitors")
    """Converted monitors"""

    config_template_as_yaml = sgqlc.types.Field(String, graphql_name="configTemplateAsYaml")
    """Config Template as YAML"""

    config_template_as_dict = sgqlc.types.Field(JSONString, graphql_name="configTemplateAsDict")
    """Config Template as a dictionary"""

    errors = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="errors")
    """Errors encountered"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="warnings")
    """Warnings encountered"""


class CorrelationSamplingMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_axis", "explanatory_field")
    time_axis = sgqlc.types.Field("TimeAxisMetadata", graphql_name="timeAxis")
    """Field used as the time axis"""

    explanatory_field = sgqlc.types.Field(
        "ExplanatoryFieldMetadata", graphql_name="explanatoryField"
    )
    """Field from which values are sampled"""


class CorrelationSamplingResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sample",)
    sample = sgqlc.types.Field(sgqlc.types.list_of("RcaPlotData"), graphql_name="sample")
    """List of value distribution samples"""


class CreateAccessToken(sgqlc.types.Type):
    """Generate an API Access Token and associate to user"""

    __schema__ = schema
    __field_names__ = ("access_token",)
    access_token = sgqlc.types.Field(AccessToken, graphql_name="accessToken")


class CreateAccountSecret(sgqlc.types.Type):
    """Create an account secret"""

    __schema__ = schema
    __field_names__ = ("secret",)
    secret = sgqlc.types.Field(AccountSecretOutput, graphql_name="secret")
    """The secret that was created"""


class CreateAzureDevOpsIntegration(sgqlc.types.Type):
    """Create a new Azure DevOps integration."""

    __schema__ = schema
    __field_names__ = ("azure_devops_integration", "oauth_redirect_url")
    azure_devops_integration = sgqlc.types.Field(
        AzureDevOpsIntegrationOutput, graphql_name="azureDevopsIntegration"
    )
    """The created integration"""

    oauth_redirect_url = sgqlc.types.Field(String, graphql_name="oauthRedirectUrl")
    """OAuth redirect URL if OAuth credentials were provided"""


class CreateAzureDevOpsWorkItemForAlert(sgqlc.types.Type):
    """Create a new Azure DevOps work item from a Monte Carlo alert.
    This mutation creates a work item in Azure DevOps and links it to
    the alert.
    """

    __schema__ = schema
    __field_names__ = ("azure_devops_work_item",)
    azure_devops_work_item = sgqlc.types.Field(
        AzureDevOpsWorkItemOutput, graphql_name="azureDevopsWorkItem"
    )


class CreateAzureDevopsInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("installation", "oauth_redirect_url")
    installation = sgqlc.types.Field(AzureDevopsInstallation, graphql_name="installation")
    """If using basic auth, the Azure DevOps installation that was
    created
    """

    oauth_redirect_url = sgqlc.types.Field(String, graphql_name="oauthRedirectUrl")


class CreateCollectorRecord(sgqlc.types.Type):
    """Create an additional collector record (with template) in the
    account.
    """

    __schema__ = schema
    __field_names__ = ("dc",)
    dc = sgqlc.types.Field("DataCollector", graphql_name="dc")
    """The data collector that was created"""


class CreateCustomMetricRule(sgqlc.types.Type):
    """Deprecated, use CreateOrUpdateCustomMetricRule instead"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreateCustomRule(sgqlc.types.Type):
    """Deprecated, use CreateOrUpdateCustomRule instead"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreateCustomUser(sgqlc.types.Type):
    """Create a CustomUser"""

    __schema__ = schema
    __field_names__ = ("custom_user",)
    custom_user = sgqlc.types.Field("CustomUser", graphql_name="customUser")


class CreateDataMaintenanceWindowFromHolidays(sgqlc.types.Type):
    """Create a data maintenance window for a set of holidays"""

    __schema__ = schema
    __field_names__ = ("entries",)
    entries = sgqlc.types.Field(sgqlc.types.list_of("DataMaintenanceEntry"), graphql_name="entries")


class CreateDatadogIncidentForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("datadog_incident",)
    datadog_incident = sgqlc.types.Field("DatadogIncident", graphql_name="datadogIncident")
    """The created Datadog incident"""


class CreateDatadogIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("datadog_integration",)
    datadog_integration = sgqlc.types.Field(
        "DatadogIntegrationOutput", graphql_name="datadogIntegration"
    )
    """The integration"""


class CreateIntegrationKey(sgqlc.types.Type):
    """Create an integration key"""

    __schema__ = schema
    __field_names__ = ("key",)
    key = sgqlc.types.Field("IntegrationKey", graphql_name="key")
    """Integration key id and secret (only available once)."""


class CreateJiraIntegration(sgqlc.types.Type):
    """Create a Jira integration"""

    __schema__ = schema
    __field_names__ = ("jira_integration",)
    jira_integration = sgqlc.types.Field("JiraIntegrationOutput", graphql_name="jiraIntegration")
    """The integration that was created"""


class CreateJiraTicketForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("jira_ticket",)
    jira_ticket = sgqlc.types.Field("JiraTicketOutput", graphql_name="jiraTicket")
    """The created Jira ticket"""


class CreateJiraTicketForIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("jira_ticket",)
    jira_ticket = sgqlc.types.Field("JiraTicketOutput", graphql_name="jiraTicket")
    """The created Jira ticket"""


class CreateLogsIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("logs_integration",)
    logs_integration = sgqlc.types.Field("LogsIntegrationOutput", graphql_name="logsIntegration")
    """The integration that was created"""


class CreateMcpIntegrationKey(sgqlc.types.Type):
    """Create an MCP integration key"""

    __schema__ = schema
    __field_names__ = ("key",)
    key = sgqlc.types.Field("IntegrationKey", graphql_name="key")
    """Integration key id and secret (only available once)."""


class CreateOpsgenieIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("opsgenie_integration",)
    opsgenie_integration = sgqlc.types.Field(
        "OpsgenieIntegrationOutput", graphql_name="opsgenieIntegration"
    )
    """The integration"""


class CreateOrUpdateAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("agent_id", "validation_result")
    agent_id = sgqlc.types.Field(UUID, graphql_name="agentId")
    """The UUID of the agent that was created or updated."""

    validation_result = sgqlc.types.Field(
        "TestCredentialsV2Response", graphql_name="validationResult"
    )
    """Result validating the provided parameters."""


class CreateOrUpdateAgentMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("agent_monitor", "queries")
    agent_monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="agentMonitor")

    queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="queries"
    )
    """SQL queries that will be run by the monitor on each execution."""


class CreateOrUpdateAgentTraceTable(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("agent_trace_table",)
    agent_trace_table = sgqlc.types.Field("AgentTraceTable", graphql_name="agentTraceTable")


class CreateOrUpdateAlationIntegration(sgqlc.types.Type):
    """Create or update Alation integration"""

    __schema__ = schema
    __field_names__ = ("alation_integration",)
    alation_integration = sgqlc.types.Field("AlationIntegration", graphql_name="alationIntegration")


class CreateOrUpdateAlationTableFlag(sgqlc.types.Type):
    """Create or update Alation flag on a table. The flag could be a
    warning or a deprecation.
    """

    __schema__ = schema
    __field_names__ = ("alation_flag_ids",)
    alation_flag_ids = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="alationFlagIds")
    """List of IDs of flags created. This list will have more than one
    entry when multiple tables matched the input full_table_id.
    """


class CreateOrUpdateAlertComment(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("comment_event",)
    comment_event = sgqlc.types.Field("Event", graphql_name="commentEvent")
    """The alert comment event."""


class CreateOrUpdateAudience(sgqlc.types.Type):
    """Create a notification audience"""

    __schema__ = schema
    __field_names__ = ("audience",)
    audience = sgqlc.types.Field("NotificationAudience", graphql_name="audience")


class CreateOrUpdateAudienceNotificationSetting(sgqlc.types.Type):
    """Create or update an audience notification setting"""

    __schema__ = schema
    __field_names__ = ("notification_setting",)
    notification_setting = sgqlc.types.Field(
        "NotificationSetting", graphql_name="notificationSetting"
    )
    """Setting that was created or updated"""


class CreateOrUpdateAudienceRoutingRule(sgqlc.types.Type):
    """Create or update an audience routing rule"""

    __schema__ = schema
    __field_names__ = ("routing_rule",)
    routing_rule = sgqlc.types.Field("NotificationRoutingRule", graphql_name="routingRule")
    """Routing rule that was created or updated"""


class CreateOrUpdateAuthProvisioning(sgqlc.types.Type):
    """Create or update an account's authorization provisioning
    configuration.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")


class CreateOrUpdateAuthorizationGroup(sgqlc.types.Type):
    """Create or update an authorization group."""

    __schema__ = schema
    __field_names__ = ("authorization_group",)
    authorization_group = sgqlc.types.Field(
        AuthorizationGroupOutput, graphql_name="authorizationGroup"
    )
    """Created or updated authorization group."""


class CreateOrUpdateCatalogObjectMetadata(sgqlc.types.Type):
    """Create or update an asset's metadata"""

    __schema__ = schema
    __field_names__ = ("catalog_object_metadata",)
    catalog_object_metadata = sgqlc.types.Field(
        "CatalogObjectMetadata", graphql_name="catalogObjectMetadata"
    )
    """Object metadata created or updated"""


class CreateOrUpdateCollibraIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("collibra_integration",)
    collibra_integration = sgqlc.types.Field(
        "CollibraIntegration", graphql_name="collibraIntegration"
    )


class CreateOrUpdateComparisonMonitor(sgqlc.types.Type):
    """Create or update a comparison monitor"""

    __schema__ = schema
    __field_names__ = ("comparison_monitor", "yaml", "source_queries", "target_queries")
    comparison_monitor = sgqlc.types.Field(
        "ComparisonMonitorResponse", graphql_name="comparisonMonitor"
    )

    yaml = sgqlc.types.Field(String, graphql_name="yaml")

    source_queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="sourceQueries"
    )
    """SQL queries that will be run by the monitor for source on each
    execution.
    """

    target_queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="targetQueries"
    )
    """SQL queries that will be run by the monitor for target on each
    execution.
    """


class CreateOrUpdateComparisonRule(sgqlc.types.Type):
    """Create or update a comparison rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule", "yaml", "queries")
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")

    queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="queries"
    )
    """SQL queries that will be run by the monitor on each execution."""


class CreateOrUpdateCustomMetricRule(sgqlc.types.Type):
    """Create or update a custom metric rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreateOrUpdateCustomRule(sgqlc.types.Type):
    """DEPRECATED. Depending on the type of monitor you would like to
    create, use CreateOrUpdateVolumeRule,
    CreateOrUpdateFreshnessCustomRule, CreateOrUpdateCustomSqlRule,
    CreateOrUpdateComparisonRule or CreateOrUpdateQueryPerfRule
    instead.
    """

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreateOrUpdateCustomSQLTemplate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("custom_sql_template",)
    custom_sql_template = sgqlc.types.Field("CustomSQLTemplate", graphql_name="customSqlTemplate")


class CreateOrUpdateCustomSqlRule(sgqlc.types.Type):
    """Create or update a custom SQL rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule", "yaml", "queries")
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")

    queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="queries"
    )
    """SQL queries that will be run by the monitor on each execution."""


class CreateOrUpdateDashboard(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dashboard",)
    dashboard = sgqlc.types.Field(sgqlc.types.non_null("CustomDashboard"), graphql_name="dashboard")
    """Dashboard configuration"""


class CreateOrUpdateDataExplorerComparisonDashboardMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_explorer_comparison_dashboard",)
    data_explorer_comparison_dashboard = sgqlc.types.Field(
        "DataExplorerComparisonDashboardType", graphql_name="dataExplorerComparisonDashboard"
    )


class CreateOrUpdateDataExplorerDashboardMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_explorer_dashboard",)
    data_explorer_dashboard = sgqlc.types.Field(
        "DataExplorerDashboardType", graphql_name="dataExplorerDashboard"
    )


class CreateOrUpdateDataMaintenanceEntry(sgqlc.types.Type):
    """Creates or updates a data maintenance period"""

    __schema__ = schema
    __field_names__ = ("entry",)
    entry = sgqlc.types.Field("DataMaintenanceEntry", graphql_name="entry")


class CreateOrUpdateDataOperationsDashboardMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_operations_dashboard",)
    data_operations_dashboard = sgqlc.types.Field(
        "DataOperationsDashboardOutput", graphql_name="dataOperationsDashboard"
    )
    """Created or updated data operations dashboard"""


class CreateOrUpdateDataProduct(sgqlc.types.Type):
    """Create or update a data product"""

    __schema__ = schema
    __field_names__ = ("data_product",)
    data_product = sgqlc.types.Field("DataProduct", graphql_name="dataProduct")
    """Created or updated data product"""


class CreateOrUpdateDataProductV2(sgqlc.types.Type):
    """Create or update a data product"""

    __schema__ = schema
    __field_names__ = ("data_product",)
    data_product = sgqlc.types.Field("DataProduct", graphql_name="dataProduct")
    """Created or updated data product"""


class CreateOrUpdateDomain(sgqlc.types.Type):
    """Create or update a domain"""

    __schema__ = schema
    __field_names__ = ("domain",)
    domain = sgqlc.types.Field("DomainOutput", graphql_name="domain")
    """Created or updated domain"""


class CreateOrUpdateFieldQualityRule(sgqlc.types.Type):
    """Create or update a field quality rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreateOrUpdateFreshnessCustomRule(sgqlc.types.Type):
    """Create or update a freshness custom rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreateOrUpdateIncidentComment(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("comment_event",)
    comment_event = sgqlc.types.Field("Event", graphql_name="commentEvent")
    """The incident comment event."""


class CreateOrUpdateJsonSchemaMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("json_schema_monitor", "yaml", "queries")
    json_schema_monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="jsonSchemaMonitor")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")

    queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="queries"
    )
    """SQL queries that will be run by the monitor on each execution."""


class CreateOrUpdateLineageEdge(sgqlc.types.Type):
    """Create or update a lineage edge"""

    __schema__ = schema
    __field_names__ = ("edge",)
    edge = sgqlc.types.Field("LineageGraphEdge", graphql_name="edge")


class CreateOrUpdateLineageNode(sgqlc.types.Type):
    """Create or update a lineage node"""

    __schema__ = schema
    __field_names__ = ("node",)
    node = sgqlc.types.Field("LineageGraphNode", graphql_name="node")


class CreateOrUpdateLineageNodeBlockPattern(sgqlc.types.Type):
    """Create or update a node block pattern"""

    __schema__ = schema
    __field_names__ = ("pattern",)
    pattern = sgqlc.types.Field("LineageNodeBlockPattern", graphql_name="pattern")


class CreateOrUpdateLineageNodeCollapsingRule(sgqlc.types.Type):
    """Create or update a node collapsing rule"""

    __schema__ = schema
    __field_names__ = ("rule",)
    rule = sgqlc.types.Field("LineageNodeCollapsingRule", graphql_name="rule")
    """Collapsing rule that was created or updated"""


class CreateOrUpdateLineageNodeReplacementRule(sgqlc.types.Type):
    """Create or update a node replacement rule"""

    __schema__ = schema
    __field_names__ = ("rule",)
    rule = sgqlc.types.Field("LineageNodeReplacementRule", graphql_name="rule")
    """Replacement rule that was created or updated"""


class CreateOrUpdateMetricMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metric_monitor", "yaml", "queries")
    metric_monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="metricMonitor")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")

    queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="queries"
    )
    """SQL queries that will be run by the monitor on each execution."""


class CreateOrUpdateMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("monitor",)
    monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="monitor")


class CreateOrUpdateMonitorComment(sgqlc.types.Type):
    """Creates or updates a comment on a monitor."""

    __schema__ = schema
    __field_names__ = ("comment",)
    comment = sgqlc.types.Field("MonitorComment", graphql_name="comment")
    """The created or updated comment"""


class CreateOrUpdateMonitorLabel(sgqlc.types.Type):
    """Create or update a monitor label"""

    __schema__ = schema
    __field_names__ = ("monitor_label",)
    monitor_label = sgqlc.types.Field("MonitorLabelObject", graphql_name="monitorLabel")
    """The created monitor label"""


class CreateOrUpdateMonteCarloConfigTemplate(sgqlc.types.Type):
    """Create or update a Monte Carlo Config Template"""

    __schema__ = schema
    __field_names__ = ("response",)
    response = sgqlc.types.Field("MonteCarloConfigTemplateUpdateResponse", graphql_name="response")
    """Response"""


class CreateOrUpdateMonteCarloConfigTemplateAsync(sgqlc.types.Type):
    """Create or update a Monte Carlo Config Template asynchronously"""

    __schema__ = schema
    __field_names__ = ("response",)
    response = sgqlc.types.Field(
        "MonteCarloConfigTemplateUpdateAsyncResponse", graphql_name="response"
    )
    """Response"""


class CreateOrUpdateNotificationSetting(sgqlc.types.Type):
    """Create or update a notification setting"""

    __schema__ = schema
    __field_names__ = ("notification_setting",)
    notification_setting = sgqlc.types.Field(
        AccountNotificationSetting, graphql_name="notificationSetting"
    )
    """Setting that was created or updated"""


class CreateOrUpdateObjectProperty(sgqlc.types.Type):
    """Create or update properties (tags) for objects (e.g. tables,
    fields, etc.)
    """

    __schema__ = schema
    __field_names__ = ("object_property",)
    object_property = sgqlc.types.Field("ObjectProperty", graphql_name="objectProperty")
    """Property created or updated"""


class CreateOrUpdateQueryPerfRule(sgqlc.types.Type):
    """Create or update query performance rule/monitor.
    There must be exactly (3) comparisons, which follow this format:
    {                 "comparisonType": "QUERY_PERFORMANCE",
    "operator": "GT",                 "metric": "runtime",
    "threshold": <THRESHOLD IN SECONDS>,             },             {
    "comparisonType": "QUERY_PERFORMANCE",                 "operator":
    "GT",                 "metric": "runtime_change",
    "threshold": <THRESHOLD AS PERCENTAGE>,
    "baselineAggFunction": <MEDIAN|AVG>,
    "thresholdLookbackDataPoints": <NUMBER OF DATA POINTS TO INCLUDE
    IN LOOKBACK RANGE>,             },             {
    "comparisonType": "QUERY_PERFORMANCE",                 "operator":
    "GT",                 "metric": "consecutive_breach_count",
    "threshold": <NUMBER OF CONSECUTIVE BREACHES TO TRIGGER AN ALERT>,
    }
    """

    __schema__ = schema
    __field_names__ = ("custom_rule", "yaml")
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")


class CreateOrUpdateRecipientName(sgqlc.types.Type):
    """Create or update a recipient's custom name"""

    __schema__ = schema
    __field_names__ = ("recipient", "name")
    recipient = sgqlc.types.Field(String, graphql_name="recipient")

    name = sgqlc.types.Field(String, graphql_name="name")


class CreateOrUpdateResource(sgqlc.types.Type):
    """Create or update a resource"""

    __schema__ = schema
    __field_names__ = ("resource",)
    resource = sgqlc.types.Field("Resource", graphql_name="resource")


class CreateOrUpdateSamlIdentityProvider(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("account",)
    account = sgqlc.types.Field(Account, graphql_name="account")


class CreateOrUpdateServiceApiToken(sgqlc.types.Type):
    """Generate a service API Access Token"""

    __schema__ = schema
    __field_names__ = ("access_token",)
    access_token = sgqlc.types.Field(AccessToken, graphql_name="accessToken")


class CreateOrUpdateTableMonitor(sgqlc.types.Type):
    """Create or update a table monitor"""

    __schema__ = schema
    __field_names__ = ("table_monitor", "yaml")
    table_monitor = sgqlc.types.Field("TableMonitor", graphql_name="tableMonitor")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")
    """YAML representation of the monitor (only returned for dry_run)"""


class CreateOrUpdateTagAssignmentsMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates if the assignments are created successfully."""


class CreateOrUpdateTagMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tag_object",)
    tag_object = sgqlc.types.Field("TagObjectOutput", graphql_name="tagObject")
    """Created or updated data operations dashboard"""


class CreateOrUpdateUserSettings(sgqlc.types.Type):
    """Create a new user-specific setting"""

    __schema__ = schema
    __field_names__ = ("user_settings",)
    user_settings = sgqlc.types.Field("UserSettings", graphql_name="userSettings")
    """Response"""


class CreateOrUpdateUserSettingsBatch(sgqlc.types.Type):
    """Create or update a list of user-specific settings"""

    __schema__ = schema
    __field_names__ = ("user_settings",)
    user_settings = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("UserSettings")), graphql_name="userSettings"
    )
    """List of updated settings"""


class CreateOrUpdateValidation(sgqlc.types.Type):
    """Create or update a validation"""

    __schema__ = schema
    __field_names__ = ("validation", "yaml", "queries")
    validation = sgqlc.types.Field("CustomRule", graphql_name="validation")

    yaml = sgqlc.types.Field(String, graphql_name="yaml")

    queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="queries"
    )
    """SQL queries that will be run by the monitor on each execution."""


class CreateOrUpdateVolumeRule(sgqlc.types.Type):
    """Create or update a Volume Rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class CreatePagerDutyServiceIntegration(sgqlc.types.Type):
    """Create a PagerDuty service integration"""

    __schema__ = schema
    __field_names__ = ("pagerduty_service_integration",)
    pagerduty_service_integration = sgqlc.types.Field(
        "PagerDutyServiceIntegrationOutput", graphql_name="pagerdutyServiceIntegration"
    )
    """The integration that was created"""


class CreateServiceNowIncidentForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("servicenow_incident",)
    servicenow_incident = sgqlc.types.Field(
        "ServiceNowIncidentOutput", graphql_name="servicenowIncident"
    )
    """The created ServiceNow incident"""


class CreateServiceNowIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("servicenow_integration",)
    servicenow_integration = sgqlc.types.Field(
        "ServiceNowIntegrationOutput", graphql_name="servicenowIntegration"
    )
    """The integration that was created"""


class CreateSharedQuery(sgqlc.types.Type):
    """Create a new shared API Explorer GraphQL query or mutation"""

    __schema__ = schema
    __field_names__ = ("link",)
    link = sgqlc.types.Field(String, graphql_name="link")
    """Link to newly shared query"""


class CreateSingleTableMonitoringNotification(sgqlc.types.Type):
    """Record that monitoring was enabled for a single table.  Must
    provide the table mcon and exactly one of a usage rule ID or a
    table monitor UUID.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """True if the event was recorded"""


class CreateTableauAssetWarning(sgqlc.types.Type):
    """Creates a warning on an asset."""

    __schema__ = schema
    __field_names__ = ("tableau_warning_id",)
    tableau_warning_id = sgqlc.types.Field(String, graphql_name="tableauWarningId")
    """ID of the created warning in Tableau ID space."""


class CreateUnifiedUserAssignment(sgqlc.types.Type):
    """Associate a UnifiedUser with a CatalogObject"""

    __schema__ = schema
    __field_names__ = ("unified_user_assignment",)
    unified_user_assignment = sgqlc.types.Field(
        "UnifiedUserAssignment", graphql_name="unifiedUserAssignment"
    )


class CreateWebexIntegration(sgqlc.types.Type):
    """Create a Webex integration"""

    __schema__ = schema
    __field_names__ = ("webex_integration",)
    webex_integration = sgqlc.types.Field("WebexIntegrationOutput", graphql_name="webexIntegration")
    """The integration that was created"""


class CreatorDimension(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("full_name", "email", "user_id")
    full_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullName")

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")

    user_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="userId")


class CreatorMonitorCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("creator", "count")
    creator = sgqlc.types.Field(sgqlc.types.non_null(CreatorDimension), graphql_name="creator")

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")


class CreatorMonitorCountsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("results", "total_count", "offset", "limit")
    results = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(CreatorMonitorCount)), graphql_name="results"
    )

    total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount")

    offset = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="offset")

    limit = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="limit")


class CustomComparisonMetric(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "display_name", "source_sql_expression", "target_sql_expression")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    source_sql_expression = sgqlc.types.Field(String, graphql_name="sourceSqlExpression")

    target_sql_expression = sgqlc.types.Field(String, graphql_name="targetSqlExpression")


class CustomDashboardConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomDashboardEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CustomDashboardEdge(sgqlc.types.Type):
    """A Relay edge containing a `CustomDashboard` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CustomDashboard", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CustomDashboardListConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomDashboardListEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CustomDashboardListEdge(sgqlc.types.Type):
    """A Relay edge containing a `CustomDashboardList` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CustomDashboardList", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CustomDashboardTimeSeriesLookup(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_series_id",)
    time_series_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="timeSeriesId")


class CustomDashboardWidgetContentData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_source_id", "data")
    data_source_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dataSourceId")

    data = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="data")
    """Content data of the widget"""


class CustomMetric(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "display_name",
        "sql_expression",
        "metric_name",
        "source_sql_expression",
        "target_sql_expression",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID to identify the custom metric"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Display name of the custom metric"""

    sql_expression = sgqlc.types.Field(String, graphql_name="sqlExpression")
    """SQL expression to evaluate for the custom metric"""

    metric_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metricName")
    """Metric name that should be used to get the values loaded for the
    custom metric
    """

    source_sql_expression = sgqlc.types.Field(String, graphql_name="sourceSqlExpression")
    """Source SQL expression to evaluate for the custom comparison metric"""

    target_sql_expression = sgqlc.types.Field(String, graphql_name="targetSqlExpression")
    """Target SQL expression to evaluate for the custom comparison metric"""


class CustomMetricQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query",)
    query = sgqlc.types.Field(String, graphql_name="query")
    """SQL query to evaluate the custom metric"""


class CustomRuleComparison(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "comparison_type",
        "full_table_id",
        "full_table_ids",
        "field",
        "fields",
        "metric",
        "custom_metric",
        "operator",
        "threshold",
        "upper_threshold",
        "lower_threshold",
        "baseline_agg_function",
        "baseline_interval_minutes",
        "is_threshold_relative",
        "is_freshness_from_metadata",
        "threshold_lookback_minutes",
        "threshold_ref",
        "threshold_sensitivity",
        "min_buffer",
        "max_buffer",
        "number_of_agg_periods",
        "data_collection_interval_minutes",
        "rule_interval_minutes",
        "threshold_lookback_data_points",
        "source_metric",
        "target_metric",
        "source_field",
        "target_field",
    )
    comparison_type = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonType), graphql_name="comparisonType"
    )
    """Type of comparison"""

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    full_table_ids = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fullTableIds")

    field = sgqlc.types.Field(String, graphql_name="field")

    fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fields"
    )

    metric = sgqlc.types.Field(String, graphql_name="metric")

    custom_metric = sgqlc.types.Field(CustomMetric, graphql_name="customMetric")
    """Custom metric, if defined with a custom metric"""

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleComparisonOperator), graphql_name="operator"
    )
    """Comparison operator"""

    threshold = sgqlc.types.Field(Float, graphql_name="threshold")
    """Threshold value"""

    upper_threshold = sgqlc.types.Field(Float, graphql_name="upperThreshold")
    """Upper threshold value"""

    lower_threshold = sgqlc.types.Field(Float, graphql_name="lowerThreshold")
    """Lower threshold value"""

    baseline_agg_function = sgqlc.types.Field(
        AggregationFunction, graphql_name="baselineAggFunction"
    )
    """Function used to aggregate historical data points to calculate
    baseline
    """

    baseline_interval_minutes = sgqlc.types.Field(Int, graphql_name="baselineIntervalMinutes")
    """Time interval to aggregate over to calculate baseline."""

    is_threshold_relative = sgqlc.types.Field(Boolean, graphql_name="isThresholdRelative")
    """True, if threshold is a relative percentage change of baseline.
    False, if threshold is absolute change
    """

    is_freshness_from_metadata = sgqlc.types.Field(Boolean, graphql_name="isFreshnessFromMetadata")
    """True if freshness is calculated from metadata."""

    threshold_lookback_minutes = sgqlc.types.Field(Int, graphql_name="thresholdLookbackMinutes")
    """Time to look back for rules which compare current and past values."""

    threshold_ref = sgqlc.types.Field(String, graphql_name="thresholdRef")
    """Key used to retrieve the threshold values from external source"""

    threshold_sensitivity = sgqlc.types.Field(
        SensitivityLevels, graphql_name="thresholdSensitivity"
    )
    """Sensitivity for automated thresholds"""

    min_buffer = sgqlc.types.Field("ThresholdModifier", graphql_name="minBuffer")
    """The lower bound buffer to modify the alert threshold"""

    max_buffer = sgqlc.types.Field("ThresholdModifier", graphql_name="maxBuffer")
    """The upper bound buffer to modify the alert threshold"""

    number_of_agg_periods = sgqlc.types.Field(Int, graphql_name="numberOfAggPeriods")
    """The number of periods to use in the aggregate comparison for
    Volume Growth comparisons.
    """

    data_collection_interval_minutes = sgqlc.types.Field(
        Int, graphql_name="dataCollectionIntervalMinutes"
    )
    """Time interval of data collection for the rule."""

    rule_interval_minutes = sgqlc.types.Field(Int, graphql_name="ruleIntervalMinutes")
    """Time interval for the rule evaluation."""

    threshold_lookback_data_points = sgqlc.types.Field(
        Int, graphql_name="thresholdLookbackDataPoints"
    )
    """Number of data points to look back for rules which compare current
    and past values.
    """

    source_metric = sgqlc.types.Field(String, graphql_name="sourceMetric")
    """Name of source metric"""

    target_metric = sgqlc.types.Field(String, graphql_name="targetMetric")
    """Name of target metric"""

    source_field = sgqlc.types.Field(String, graphql_name="sourceField")
    """Name of source field"""

    target_field = sgqlc.types.Field(String, graphql_name="targetField")
    """Name of target field"""


class CustomRuleConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomRuleEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CustomRuleEdge(sgqlc.types.Type):
    """A Relay edge containing a `CustomRule` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CustomRule", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CustomRuleExecutionAnalytics(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("date", "runs", "passes", "breaches")
    date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="date")
    """Date for the analytics, if grouped by week/month it has the start
    of each grouping period
    """

    runs = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="runs")
    """Number of runs"""

    passes = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="passes")
    """Number of passes"""

    breaches = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="breaches")
    """Number of breaches"""


class CustomRuleQueryConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomRuleQueryEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CustomRuleQueryEdge(sgqlc.types.Type):
    """A Relay edge containing a `CustomRuleQuery` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CustomRuleQuery", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CustomRuleSqlBlocks(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("alert_condition", "where_condition", "group_by")
    alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null("FilterGroup"), graphql_name="alertCondition"
    )

    where_condition = sgqlc.types.Field(
        sgqlc.types.non_null("FilterGroup"), graphql_name="whereCondition"
    )

    group_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface))),
        graphql_name="groupBy",
    )


class CustomSQLOutputDownload(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sampling_disabled", "download_url")
    sampling_disabled = sgqlc.types.Field(Boolean, graphql_name="samplingDisabled")

    download_url = sgqlc.types.Field(String, graphql_name="downloadUrl")
    """Link to download the query response which expires in 5 minutes."""


class CustomSQLOutputSample(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "columns",
        "rows",
        "matches",
        "sampling_disabled",
        "next_file_index",
        "total_samples_size",
    )
    columns = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="columns")

    rows = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.list_of(String)), graphql_name="rows")

    matches = sgqlc.types.Field(sgqlc.types.list_of(ConditionMatches), graphql_name="matches")

    sampling_disabled = sgqlc.types.Field(Boolean, graphql_name="samplingDisabled")

    next_file_index = sgqlc.types.Field(Int, graphql_name="nextFileIndex")
    """Next file index to retrieve."""

    total_samples_size = sgqlc.types.Field(Int, graphql_name="totalSamplesSize")
    """Total number of samples retrieved."""


class CustomSQLTemplateConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count", "edge_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomSQLTemplateEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")


class CustomSQLTemplateEdge(sgqlc.types.Type):
    """A Relay edge containing a `CustomSQLTemplate` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CustomSQLTemplate", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class CustomUserConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("CustomUserEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class CustomUserEdge(sgqlc.types.Type):
    """A Relay edge containing a `CustomUser` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("CustomUser", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DODCriteriaOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "time_range",
        "data_product_uuids",
        "audience_uuids",
        "domain_uuids",
        "tags",
        "monitor_tags",
    )
    time_range = sgqlc.types.Field(
        sgqlc.types.non_null("TimeRangeOutput"), graphql_name="timeRange"
    )
    """Time range criteria."""

    data_product_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(UUID), graphql_name="dataProductUuids"
    )
    """Data Product UUIDs."""

    audience_uuids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="audienceUuids")
    """Audience UUIDs."""

    domain_uuids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="domainUuids")
    """Domain UUIDs."""

    tags = sgqlc.types.Field(sgqlc.types.list_of("TagKeyValuePairOutput"), graphql_name="tags")
    """Tags."""

    monitor_tags = sgqlc.types.Field(
        sgqlc.types.list_of("TagKeyValuePairOutput"), graphql_name="monitorTags"
    )
    """Monitor tags filters."""


class DailyUsage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("date", "requests_used", "requests_remaining")
    date = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="date")

    requests_used = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="requestsUsed")

    requests_remaining = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="requestsRemaining"
    )


class DataAssetDashboard(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "data_sources_count",
        "project_count",
        "schema_count",
        "table_count",
        "view_count",
        "external_table_count",
        "wildcard_table_count",
    )
    data_sources_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="dataSourcesCount"
    )
    """The number of data sources monitored"""

    project_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="projectCount")
    """The number of projects monitored"""

    schema_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="schemaCount")
    """The number of schemas monitored"""

    table_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="tableCount")
    """The number of tables monitored"""

    view_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="viewCount")
    """The number of views monitored"""

    external_table_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="externalTableCount"
    )
    """The number of external tables monitored"""

    wildcard_table_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="wildcardTableCount"
    )
    """The number of wildcard tables monitored"""


class DataCollector(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "account",
        "uuid",
        "name",
        "api_gateway_id",
        "kinesis_endpoint_id",
        "cloudwatch_log_endpoint_id",
        "cross_account_role_arn",
        "stack_arn",
        "customer_aws_account_id",
        "customer_aws_region",
        "template_launch_url",
        "template_provider",
        "template_variant",
        "template_version",
        "template_parameters",
        "code_version",
        "kinesis_access_role",
        "active",
        "last_updated",
        "is_custom",
        "oauth_credentials_s3_key",
        "release_channel",
        "warehouses",
        "bi_container",
        "etl_container",
        "agents",
        "supports_data_store_agents",
        "supports_remote_agents",
        "collection_node",
        "collection_storage",
        "deployment_type",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    name = sgqlc.types.Field(String, graphql_name="name")

    api_gateway_id = sgqlc.types.Field(String, graphql_name="apiGatewayId")

    kinesis_endpoint_id = sgqlc.types.Field(String, graphql_name="kinesisEndpointId")

    cloudwatch_log_endpoint_id = sgqlc.types.Field(String, graphql_name="cloudwatchLogEndpointId")

    cross_account_role_arn = sgqlc.types.Field(String, graphql_name="crossAccountRoleArn")

    stack_arn = sgqlc.types.Field(String, graphql_name="stackArn")

    customer_aws_account_id = sgqlc.types.Field(String, graphql_name="customerAwsAccountId")

    customer_aws_region = sgqlc.types.Field(String, graphql_name="customerAwsRegion")

    template_launch_url = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="templateLaunchUrl"
    )

    template_provider = sgqlc.types.Field(String, graphql_name="templateProvider")

    template_variant = sgqlc.types.Field(String, graphql_name="templateVariant")

    template_version = sgqlc.types.Field(String, graphql_name="templateVersion")

    template_parameters = sgqlc.types.Field(JSONString, graphql_name="templateParameters")

    code_version = sgqlc.types.Field(String, graphql_name="codeVersion")

    kinesis_access_role = sgqlc.types.Field(String, graphql_name="kinesisAccessRole")

    active = sgqlc.types.Field(Boolean, graphql_name="active")

    last_updated = sgqlc.types.Field(DateTime, graphql_name="lastUpdated")

    is_custom = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCustom")

    oauth_credentials_s3_key = sgqlc.types.Field(String, graphql_name="oauthCredentialsS3Key")

    release_channel = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="releaseChannel")
    """[PENDING DEPRECATION WARNING] This field only applies to legacy
    data collectors that are updated via the legacy release train. V2
    collectors (CaaS) are updated via the CaaS release train, where
    release channels are tracked in the CollectionNodeModel. See
    https://mc-d.io/trains for more details on the CaaS release train.
    """

    warehouses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Warehouse"))),
        graphql_name="warehouses",
    )

    bi_container = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(BiContainer))),
        graphql_name="biContainer",
    )

    etl_container = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("EtlContainer"))),
        graphql_name="etlContainer",
    )

    agents = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Agent))),
        graphql_name="agents",
    )
    """Agents associated with the data collector"""

    supports_data_store_agents = sgqlc.types.Field(Boolean, graphql_name="supportsDataStoreAgents")
    """Indicates whether the data collector's version supports data store
    agents
    """

    supports_remote_agents = sgqlc.types.Field(Boolean, graphql_name="supportsRemoteAgents")
    """Indicates whether the data collector's version supports remote
    agents
    """

    collection_node = sgqlc.types.Field(CollectionNode, graphql_name="collectionNode")
    """CaaS node associated to this DC"""

    collection_storage = sgqlc.types.Field(CollectionStorage, graphql_name="collectionStorage")
    """CaaS storage associated to this DC"""

    deployment_type = sgqlc.types.Field(
        DataCollectorModelDeploymentTypeEnum, graphql_name="deploymentType"
    )
    """Deprecated - use getPlatformServices.deployment.deploymentType
    instead
    """


class DataCollectorSchedule(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "dc_id",
        "resource_id",
        "connection_id",
        "project_id",
        "output_stream",
        "output_s3_bucket",
        "last_job_id",
        "job_type",
        "schedule_type",
        "created_on",
        "override",
        "skip",
        "last_run",
        "interval_in_seconds",
        "interval_crontab",
        "interval_crontab_lag_minutes",
        "interval_crontab_day_or",
        "start_time",
        "prev_execution_time",
        "next_execution_time",
        "timezone",
        "dynamic_schedule_mcons",
        "is_dynamic_schedule_poller",
        "min_interval_seconds",
        "is_automatic",
        "friendly_name",
        "notes",
        "limits",
        "is_deleted",
        "delete_reason",
        "skip_reason",
        "queued_at",
        "metric_monitors",
        "custom_rules",
        "agent_trace_tables",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    dc_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dcId")

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")

    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")

    project_id = sgqlc.types.Field(String, graphql_name="projectId")

    output_stream = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="outputStream")

    output_s3_bucket = sgqlc.types.Field(String, graphql_name="outputS3Bucket")

    last_job_id = sgqlc.types.Field(String, graphql_name="lastJobId")

    job_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobType")

    schedule_type = sgqlc.types.Field(
        sgqlc.types.non_null(DataCollectorScheduleModelScheduleType), graphql_name="scheduleType"
    )

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    override = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="override")

    skip = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="skip")

    last_run = sgqlc.types.Field(DateTime, graphql_name="lastRun")

    interval_in_seconds = sgqlc.types.Field(Int, graphql_name="intervalInSeconds")

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="intervalCrontab"
    )

    interval_crontab_lag_minutes = sgqlc.types.Field(Int, graphql_name="intervalCrontabLagMinutes")

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")

    prev_execution_time = sgqlc.types.Field(DateTime, graphql_name="prevExecutionTime")

    next_execution_time = sgqlc.types.Field(DateTime, graphql_name="nextExecutionTime")

    timezone = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timezone")

    dynamic_schedule_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="dynamicScheduleMcons"
    )
    """Mcons of tables that trigger the schedule on update"""

    is_dynamic_schedule_poller = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isDynamicSchedulePoller"
    )
    """If true, this schedule is for used to poll forfreshness to trigger
    dynamically scheduled jobs
    """

    min_interval_seconds = sgqlc.types.Field(Int, graphql_name="minIntervalSeconds")
    """Minimum interval between job executions. Used to preventa dynamic
    scheduled job from executing too frequently
    """

    is_automatic = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAutomatic")
    """If true, it was scheduled automatically based on job configuration"""

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")

    notes = sgqlc.types.Field(String, graphql_name="notes")

    limits = sgqlc.types.Field(JSONString, graphql_name="limits")

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    delete_reason = sgqlc.types.Field(
        DataCollectorScheduleModelDeleteReason, graphql_name="deleteReason"
    )

    skip_reason = sgqlc.types.Field(DataCollectorScheduleModelSkipReason, graphql_name="skipReason")
    """This field will be set when the schedule is set to skip=true froma
    manual action or when the connection is disabled.
    """

    queued_at = sgqlc.types.Field(DateTime, graphql_name="queuedAt")
    """The last time this schedule was added to the execution queue"""

    metric_monitors = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonMonitorResponseConnection),
        graphql_name="metricMonitors",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    custom_rules = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleConnection),
        graphql_name="customRules",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "rule_type",
                    sgqlc.types.Arg(CustomRuleModelRuleType, graphql_name="ruleType", default=None),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `rule_type` (`CustomRuleModelRuleType`)None
    * `warehouse_uuid` (`UUID`)None
    """

    agent_trace_tables = sgqlc.types.Field(
        sgqlc.types.non_null(AgentTraceTableConnection),
        graphql_name="agentTraceTables",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DataCollectorScheduleInfo(sgqlc.types.Type):
    """Detailed information about a data collector schedule"""

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "resource_id",
        "connection_id",
        "internal_job_type",
        "limits",
        "interval_in_seconds",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the schedule"""

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="resourceId")
    """Resource ID (warehouse UUID) this schedule belongs to"""

    connection_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="connectionId")
    """Connection ID this schedule belongs to"""

    internal_job_type = sgqlc.types.Field(
        sgqlc.types.non_null(InternalJobType), graphql_name="internalJobType"
    )
    """Type of job (metadata, query_logs, etc.)"""

    limits = sgqlc.types.Field(JSONString, graphql_name="limits")
    """Limits configuration for the job"""

    interval_in_seconds = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="intervalInSeconds"
    )
    """Interval between job runs in seconds"""


class DataExplorerComparisonDashboardTypeConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DataExplorerComparisonDashboardTypeEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class DataExplorerComparisonDashboardTypeEdge(sgqlc.types.Type):
    """A Relay edge containing a `DataExplorerComparisonDashboardType`
    and its cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DataExplorerComparisonDashboardType", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DataExplorerDashboardTypeConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DataExplorerDashboardTypeEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class DataExplorerDashboardTypeEdge(sgqlc.types.Type):
    """A Relay edge containing a `DataExplorerDashboardType` and its
    cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DataExplorerDashboardType", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DataExplorerWidgetTypeConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DataExplorerWidgetTypeEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class DataExplorerWidgetTypeEdge(sgqlc.types.Type):
    """A Relay edge containing a `DataExplorerWidgetType` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DataExplorerWidgetType", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DataExportURL(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("url", "created_at")
    url = sgqlc.types.Field(String, graphql_name="url")
    """Pre-signed URL for fetching report, expiration time is 1 minute"""

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """Report creation time in UTC"""


class DataMaintenanceEntry(sgqlc.types.Type):
    """Data maintenance entry"""

    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "id",
        "account_uuid",
        "resource_uuid",
        "database",
        "dataset",
        "full_table_id",
        "monitor_id",
        "time_series_uuid",
        "maintenance_type",
        "start_time",
        "end_time",
        "reason",
        "reason_type",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")

    resource_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceUuid")

    database = sgqlc.types.Field(String, graphql_name="database")

    dataset = sgqlc.types.Field(String, graphql_name="dataset")

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    monitor_id = sgqlc.types.Field(UUID, graphql_name="monitorId")

    time_series_uuid = sgqlc.types.Field(UUID, graphql_name="timeSeriesUuid")

    maintenance_type = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="maintenanceType")

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")

    reason = sgqlc.types.Field(String, graphql_name="reason")

    reason_type = sgqlc.types.Field(
        sgqlc.types.non_null(DataMaintenanceReasonType), graphql_name="reasonType"
    )


class DataOperationsDashboardOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "name",
        "criteria",
        "created_by",
        "updated_by",
        "description",
        "created_time",
        "updated_time",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the Data Operations Dashboard."""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the Data Operations Dashboard."""

    criteria = sgqlc.types.Field(sgqlc.types.non_null(DODCriteriaOutput), graphql_name="criteria")
    """Data Operations Dashboard Criteria."""

    created_by = sgqlc.types.Field(sgqlc.types.non_null("UserInfoOutput"), graphql_name="createdBy")
    """Created by user of the dashboard."""

    updated_by = sgqlc.types.Field(sgqlc.types.non_null("UserInfoOutput"), graphql_name="updatedBy")
    """Last updated user of the dashboard."""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description of the Data Operations Dashboard."""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the dashboard's created."""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the dashboard's created."""


class DataPoint(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("timestamp", "value")
    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")


class DataProductAssetConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DataProductAssetEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DataProductAssetData(sgqlc.types.Type):
    """Information about an asset related to data product usage and
    recommendations
    """

    __schema__ = schema
    __field_names__ = ("data_products", "mcon", "table", "pipeline_end_node", "pipelines")
    data_products = sgqlc.types.Field(
        sgqlc.types.list_of("DataProduct"), graphql_name="dataProducts"
    )
    """UUIDs of d"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MC unique identifier"""

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")
    """Table entity for requesting"""

    pipeline_end_node = sgqlc.types.Field(Boolean, graphql_name="pipelineEndNode")
    """Whether this is an end node for an important data pipeline"""

    pipelines = sgqlc.types.Field(
        sgqlc.types.list_of("DataProductPipeline"), graphql_name="pipelines"
    )
    """Pipelines node is a member of"""


class DataProductAssetEdge(sgqlc.types.Type):
    """A Relay edge containing a `DataProductAsset` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DataProductAsset", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DataProductConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DataProductEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DataProductDryRunTableCounts(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "total_asset_count",
        "total_asset_monitored_count",
        "total_asset_unmonitored_count",
    )
    total_asset_count = sgqlc.types.Field(Int, graphql_name="totalAssetCount")
    """Total count of assets that would be in the data product"""

    total_asset_monitored_count = sgqlc.types.Field(Int, graphql_name="totalAssetMonitoredCount")
    """Total count of already monitored assets"""

    total_asset_unmonitored_count = sgqlc.types.Field(
        Int, graphql_name="totalAssetUnmonitoredCount"
    )
    """Total count of yet unmonitored assets"""


class DataProductEdge(sgqlc.types.Type):
    """A Relay edge containing a `DataProduct` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DataProduct", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DataProductMetricData(sgqlc.types.Type):
    """Data product metric with calculated data points"""

    __schema__ = schema
    __field_names__ = ("metric", "data_points", "fill_missing_data_points_with", "overall_value")
    metric = sgqlc.types.Field(sgqlc.types.non_null(DataProductMetric), graphql_name="metric")
    """Metric identifier"""

    data_points = sgqlc.types.Field(
        sgqlc.types.list_of("DataProductMetricDataPoint"), graphql_name="dataPoints"
    )
    """Data points for the metric"""

    fill_missing_data_points_with = sgqlc.types.Field(
        Float, graphql_name="fillMissingDataPointsWith"
    )
    """Value to use for missing data points. This is used to tell the FE
    which is the value to use when there is no data for a specific
    date or time.
    """

    overall_value = sgqlc.types.Field(Float, graphql_name="overallValue")
    """Overall value for the metric that is not grouped into data points"""


class DataProductMetricDataPoint(sgqlc.types.Type):
    """Data point for a data product metric"""

    __schema__ = schema
    __field_names__ = ("label", "value")
    label = sgqlc.types.Field(String, graphql_name="label")
    """Label associated to the value"""

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")
    """Value for the data point"""


class DataProductPipeline(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("pipe_mcon", "pipe_full_id", "pipe_display_name", "pipe_score")
    pipe_mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pipeMcon")

    pipe_full_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pipeFullId")

    pipe_display_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="pipeDisplayName"
    )

    pipe_score = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="pipeScore")


class DataProductUpstreamCoverageData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "total_upstream_count",
        "total_upstream_monitored_count",
        "total_upstream_unmonitored_count",
        "total_asset_count",
        "total_asset_monitored_count",
        "total_asset_unmonitored_count",
        "asset_data",
    )
    total_upstream_count = sgqlc.types.Field(Int, graphql_name="totalUpstreamCount")
    """Total count of upstream monitorable assets"""

    total_upstream_monitored_count = sgqlc.types.Field(
        Int, graphql_name="totalUpstreamMonitoredCount"
    )
    """Total count of upstream monitored assets"""

    total_upstream_unmonitored_count = sgqlc.types.Field(
        Int, graphql_name="totalUpstreamUnmonitoredCount"
    )
    """Total count of upstream unmonitored assets"""

    total_asset_count = sgqlc.types.Field(Int, graphql_name="totalAssetCount")
    """Total count of monitorable assets"""

    total_asset_monitored_count = sgqlc.types.Field(Int, graphql_name="totalAssetMonitoredCount")
    """Total count of monitored assets"""

    total_asset_unmonitored_count = sgqlc.types.Field(
        Int, graphql_name="totalAssetUnmonitoredCount"
    )
    """Total count of unmonitored assets"""

    asset_data = sgqlc.types.Field(
        sgqlc.types.list_of("TableUpstreamData"), graphql_name="assetData"
    )
    """Per asset upstream counts"""


class DataProfileField(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "type", "min", "max", "p25", "p50", "p75", "dist")
    name = sgqlc.types.Field(String, graphql_name="name")

    type = sgqlc.types.Field(String, graphql_name="type")

    min = sgqlc.types.Field(Float, graphql_name="min")

    max = sgqlc.types.Field(Float, graphql_name="max")

    p25 = sgqlc.types.Field(Float, graphql_name="p25")

    p50 = sgqlc.types.Field(Float, graphql_name="p50")

    p75 = sgqlc.types.Field(Float, graphql_name="p75")

    dist = sgqlc.types.Field(JSONString, graphql_name="dist")


class DataProfileResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sample_size", "fields")
    sample_size = sgqlc.types.Field(Int, graphql_name="sampleSize")

    fields = sgqlc.types.Field(sgqlc.types.list_of(DataProfileField), graphql_name="fields")


class DataQualityWarningsRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "author",
        "is_severe",
        "is_active",
        "warning_type",
        "message",
        "created_at",
        "updated_at",
    )
    name = sgqlc.types.Field(String, graphql_name="name")

    author = sgqlc.types.Field(AuthorRef, graphql_name="author")

    is_severe = sgqlc.types.Field(String, graphql_name="isSevere")

    is_active = sgqlc.types.Field(String, graphql_name="isActive")

    warning_type = sgqlc.types.Field(String, graphql_name="warningType")

    message = sgqlc.types.Field(String, graphql_name="message")

    created_at = sgqlc.types.Field(String, graphql_name="createdAt")

    updated_at = sgqlc.types.Field(String, graphql_name="updatedAt")


class DataResponseType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "data_frame",
        "sql_query",
        "presigned_url",
        "is_customer_hosted_data",
        "response_metadata",
    )
    data_frame = sgqlc.types.Field(JSONString, graphql_name="dataFrame")

    sql_query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlQuery")
    """Raw SQL query that produced this data"""

    presigned_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="presignedUrl")
    """Presigned URL containing data output"""

    is_customer_hosted_data = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isCustomerHostedData"
    )
    """If true, data is located at a customer-hosted object storage"""

    response_metadata = sgqlc.types.Field(
        "QueryResponseMetadataType", graphql_name="responseMetadata"
    )
    """Provides metadata that describes how response is structured."""


class DataShareOutput(sgqlc.types.Type):
    """Data share configuration details"""

    __schema__ = schema
    __field_names__ = ("type", "account", "region", "organization")
    type = sgqlc.types.Field(String, graphql_name="type")
    """Type of data share (e.g., 'snowflake')"""

    account = sgqlc.types.Field(String, graphql_name="account")
    """Data share account identifier"""

    region = sgqlc.types.Field(String, graphql_name="region")
    """Data share region"""

    organization = sgqlc.types.Field(String, graphql_name="organization")
    """Data share organization identifier"""


class DataSourceEvaluationResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "data_source",
        "connection_uuid",
        "warehouse_uuid",
        "mcons",
        "errors",
        "row_count",
        "unresolved_mcons",
        "where_condition",
        "segments",
    )
    data_source = sgqlc.types.Field(
        sgqlc.types.non_null(DataSourceInterface), graphql_name="dataSource"
    )

    connection_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="connectionUuid")

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")

    mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="mcons",
    )

    errors = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Error"))),
        graphql_name="errors",
    )

    row_count = sgqlc.types.Field(Int, graphql_name="rowCount")

    unresolved_mcons = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="unresolvedMcons"
    )

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")

    segments = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface)), graphql_name="segments"
    )


class DataSourceSchema(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("fields",)
    fields = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SchemaField"))),
        graphql_name="fields",
    )


class DatabricksJobConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DatabricksJobEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DatabricksJobEdge(sgqlc.types.Type):
    """A Relay edge containing a `DatabricksJob` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DatabricksJob", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DatabricksJobRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DatabricksJobRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DatabricksJobRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `DatabricksJobRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DatabricksJobRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DatabricksJobRunsConnection(sgqlc.types.relay.Connection):
    """Databricks job executions response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DatabricksJobRunsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class DatabricksJobRunsEdge(sgqlc.types.Type):
    """A Relay edge containing a `DatabricksJobRuns` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DatabricksJobRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DatabricksTaskConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DatabricksTaskEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DatabricksTaskEdge(sgqlc.types.Type):
    """A Relay edge containing a `DatabricksTask` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DatabricksTask", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DatabricksTaskRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DatabricksTaskRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DatabricksTaskRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `DatabricksTaskRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DatabricksTaskRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DatabricksWarehouseResponse(sgqlc.types.Type):
    """Databricks warehouse details."""

    __schema__ = schema
    __field_names__ = ("warehouse_id", "state")
    warehouse_id = sgqlc.types.Field(String, graphql_name="warehouseId")
    """ID of the warehouse."""

    state = sgqlc.types.Field(String, graphql_name="state")
    """State of the warehouse."""


class DatadogIntegrationOutput(sgqlc.types.Type):
    """A Datadog integration"""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "site",
        "default_incident_fields",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """A short name to identify the integration"""

    site = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="site")
    """Datadog site (e.g. datadoghq.com)"""

    default_incident_fields = sgqlc.types.Field(JSONString, graphql_name="defaultIncidentFields")
    """Default values for Datadog incident fields"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the integration"""


class DatadogServiceOutput(sgqlc.types.Type):
    """A Datadog incident service"""

    __schema__ = schema
    __field_names__ = ("id", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Datadog service id"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Service name"""


class DatadogTeamOutput(sgqlc.types.Type):
    """A Datadog incident team"""

    __schema__ = schema
    __field_names__ = ("id", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Datadog team id"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Team name"""


class DatadogUserOutput(sgqlc.types.Type):
    """A Datadog user"""

    __schema__ = schema
    __field_names__ = ("id", "email", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Datadog user id"""

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")
    """User email"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """User name"""


class DatasetConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DatasetEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DatasetEdge(sgqlc.types.Type):
    """A Relay edge containing a `Dataset` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("Dataset", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DatasetEntity(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dataset_id",)
    dataset_id = sgqlc.types.Field(String, graphql_name="datasetId")
    """Dataset ID"""


class DbtConnectionDetails(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_cloud_account_id", "dbt_cloud_webhook_id", "dbt_cloud_base_url")
    dbt_cloud_account_id = sgqlc.types.Field(String, graphql_name="dbtCloudAccountId")

    dbt_cloud_webhook_id = sgqlc.types.Field(String, graphql_name="dbtCloudWebhookId")

    dbt_cloud_base_url = sgqlc.types.Field(String, graphql_name="dbtCloudBaseUrl")


class DbtEdgeConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtEdgeEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtEdgeEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtEdge` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtEdge", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtJobConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtJobEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtJobEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtJob` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtJob", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtJobExecutionConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtJobExecutionEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtJobExecutionEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtJobExecution` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtJobExecution", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtJobExecutionsConnection(sgqlc.types.relay.Connection):
    """dbt job executions response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtJobExecutionsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class DbtJobExecutionsEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtJobExecutions` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtJobExecution", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtJobInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "integration_type",
        "job_name",
        "mc_dbt_job_mcon",
        "mc_dbt_job_execution_id",
        "mc_dbt_run_id",
        "dbt_cloud_job_id",
        "dbt_cloud_run_id",
        "dbt_node_id",
        "dbt_node_name",
        "invocation_id",
    )
    integration_type = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationType"
    )
    """Type of Integration"""

    job_name = sgqlc.types.Field(String, graphql_name="jobName")
    """Name of Job"""

    mc_dbt_job_mcon = sgqlc.types.Field(String, graphql_name="mcDbtJobMcon")
    """MC dbt Job mcon"""

    mc_dbt_job_execution_id = sgqlc.types.Field(UUID, graphql_name="mcDbtJobExecutionId")
    """MC dbt Job Execution ID (uuid)"""

    mc_dbt_run_id = sgqlc.types.Field(UUID, graphql_name="mcDbtRunId")
    """MC dbt Run ID (uuid)"""

    dbt_cloud_job_id = sgqlc.types.Field(String, graphql_name="dbtCloudJobId")
    """dbt Cloud Job ID"""

    dbt_cloud_run_id = sgqlc.types.Field(String, graphql_name="dbtCloudRunId")
    """dbt Cloud Run ID"""

    dbt_node_id = sgqlc.types.Field(String, graphql_name="dbtNodeId")
    """dbt node ID"""

    dbt_node_name = sgqlc.types.Field(String, graphql_name="dbtNodeName")
    """dbt node name"""

    invocation_id = sgqlc.types.Field(String, graphql_name="invocationId")
    """dbt Invocation ID"""


class DbtModelResult(sgqlc.types.Type):
    """dbt model result"""

    __schema__ = schema
    __field_names__ = ("node_id", "node_name", "schema", "database")
    node_id = sgqlc.types.Field(String, graphql_name="nodeId")
    """dbt node id"""

    node_name = sgqlc.types.Field(String, graphql_name="nodeName")
    """dbt node name"""

    schema = sgqlc.types.Field(String, graphql_name="schema")
    """dbt schema name"""

    database = sgqlc.types.Field(String, graphql_name="database")
    """dbt database name"""


class DbtModelResultsConnection(sgqlc.types.relay.Connection):
    """dbt model results response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtModelResultsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class DbtModelResultsEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtModelResults` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtRunResult", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtModelsConnection(sgqlc.types.relay.Connection):
    """dbt models response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtModelsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class DbtModelsEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtModels` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(DbtModelResult, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtNodeConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtNodeEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtNodeEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtNode` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtNode", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtNodeResultCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes_count",)
    nodes_count = sgqlc.types.Field(
        sgqlc.types.list_of("DbtResultCount"), graphql_name="nodesCount"
    )
    """List of dbt nodes and their counts"""


class DbtProjectConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtProjectEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtProjectEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtProject` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtProject", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtResultCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("count", "node_type")
    count = sgqlc.types.Field(Int, graphql_name="count")
    """Number of dbt nodes"""

    node_type = sgqlc.types.Field(String, graphql_name="nodeType")
    """Type of dbt node"""


class DbtRunConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtRunEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtRunEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtRun` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtRun", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtRunResult(sgqlc.types.Type):
    """dbt run result"""

    __schema__ = schema
    __field_names__ = (
        "node_id",
        "node_name",
        "run_started_at",
        "started_at",
        "execution_time",
        "status",
        "run_uuid",
        "mcon",
        "job_name",
        "job_mcon",
        "command",
    )
    node_id = sgqlc.types.Field(String, graphql_name="nodeId")
    """dbt node id"""

    node_name = sgqlc.types.Field(String, graphql_name="nodeName")
    """dbt node name"""

    run_started_at = sgqlc.types.Field(DateTime, graphql_name="runStartedAt")
    """Time dbt run started"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Time dbt node execution started"""

    execution_time = sgqlc.types.Field(Float, graphql_name="executionTime")
    """Total dbt node execution time (in seconds)"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Execution status"""

    run_uuid = sgqlc.types.Field(UUID, graphql_name="runUuid")
    """Internal id of dbt run"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON of associated table"""

    job_name = sgqlc.types.Field(String, graphql_name="jobName")
    """Dbt job name"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of associated dbt job"""

    command = sgqlc.types.Field(String, graphql_name="command")
    """dbt command executed"""


class DbtRunStepConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtRunStepEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DbtRunStepEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtRunStep` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtRunStep", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtTestResultsConnection(sgqlc.types.relay.Connection):
    """dbt test results response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DbtTestResultsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class DbtTestResultsEdge(sgqlc.types.Type):
    """A Relay edge containing a `DbtTestResults` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DbtTestRunResult", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DbtTestRunResult(sgqlc.types.Type):
    """dbt test run result"""

    __schema__ = schema
    __field_names__ = (
        "node_id",
        "node_name",
        "run_started_at",
        "started_at",
        "execution_time",
        "status",
        "run_uuid",
        "mcon",
        "job_name",
        "job_mcon",
        "command",
        "model_id",
        "model_name",
    )
    node_id = sgqlc.types.Field(String, graphql_name="nodeId")
    """dbt node id"""

    node_name = sgqlc.types.Field(String, graphql_name="nodeName")
    """dbt node name"""

    run_started_at = sgqlc.types.Field(DateTime, graphql_name="runStartedAt")
    """Time dbt run started"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Time dbt node execution started"""

    execution_time = sgqlc.types.Field(Float, graphql_name="executionTime")
    """Total dbt node execution time (in seconds)"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Execution status"""

    run_uuid = sgqlc.types.Field(UUID, graphql_name="runUuid")
    """Internal id of dbt run"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON of associated table"""

    job_name = sgqlc.types.Field(String, graphql_name="jobName")
    """Dbt job name"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of associated dbt job"""

    command = sgqlc.types.Field(String, graphql_name="command")
    """dbt command executed"""

    model_id = sgqlc.types.Field(String, graphql_name="modelId")
    """Id of associated dbt model"""

    model_name = sgqlc.types.Field(String, graphql_name="modelName")
    """Name of associated dbt model"""


class DcMigrationStatusResponse(sgqlc.types.Type):
    """DC migration status"""

    __schema__ = schema
    __field_names__ = ("output",)
    output = sgqlc.types.Field(GenericScalar, graphql_name="output")
    """Output from the migration process"""


class DcPingResponse(sgqlc.types.Type):
    """Describes the result of pinging a data collector."""

    __schema__ = schema
    __field_names__ = ("dc_id", "trace_id")
    dc_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dcId")
    """The UUID identifying the data collector pinged."""

    trace_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="traceId")
    """A unique identifier for correlating the data collector ping."""


class DeauthorizeSlackAppMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteAccessToken(sgqlc.types.Type):
    """Delete an API Access Token by ID"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """If the token was successfully deleted"""


class DeleteAccountSecret(sgqlc.types.Type):
    """Delete an account secret"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteAgentTraceTable(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the agent trace table was successfully deleted"""


class DeleteAlationIntegration(sgqlc.types.Type):
    """Delete Alation integration"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteAlertComment(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteAllowListEntry(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "project_name", "dataset")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""

    project_name = sgqlc.types.Field(String, graphql_name="projectName")
    """The project_name from which the dataset was deleted"""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """The dataset which was deleted."""


class DeleteAssetCollectionPreferences(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "resource_id", "asset_type")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""

    resource_id = sgqlc.types.Field(UUID, graphql_name="resourceId")
    """The resource UUID the preferences were removed from."""

    asset_type = sgqlc.types.Field(String, graphql_name="assetType")
    """The asset type that the preferences were removed for."""


class DeleteAudienceNotificationSetting(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Int, graphql_name="deleted")


class DeleteAudienceRoutingRule(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Int, graphql_name="deleted")


class DeleteAuthorizationGroup(sgqlc.types.Type):
    """Delete an authorization group"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Int, graphql_name="deleted")
    """Number of groups deleted."""


class DeleteAzureDevOpsIntegration(sgqlc.types.Type):
    """Delete an Azure DevOps integration."""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """If the integration was deleted"""


class DeleteAzureDevopsInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if deleting the installation was successful"""


class DeleteCatalogObjectMetadata(sgqlc.types.Type):
    """Delete metadata for an asset"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteCollibraIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteCustomDashboardWidget(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteCustomRule(sgqlc.types.Type):
    """Delete a custom rule"""

    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")


class DeleteCustomSQLTemplate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteDashboard(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteDataExplorerComparisonDashboardMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")


class DeleteDataExplorerDashboardMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteDataMaintenanceEntry(sgqlc.types.Type):
    """Delete a data maintenance window"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteDataOperationsDashboardMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the delete happened successfully or not."""


class DeleteDataProduct(sgqlc.types.Type):
    """Delete a data product"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Status of the deletion operation."""


class DeleteDataProductV2(sgqlc.types.Type):
    """Delete a data product"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Status of the deletion operation."""


class DeleteDatadogIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """If the integration was deleted"""


class DeleteDomain(sgqlc.types.Type):
    """Delete a domain"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Int, graphql_name="deleted")
    """Number of domains deleted"""


class DeleteEventOnboardingData(sgqlc.types.Type):
    """Delete stored event onboarding configuration"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the event onboarding data was deleted
    successfully
    """


class DeleteGithubInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """True if deleting the installation was successful"""


class DeleteGitlabInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """True if deleting the installation was successful"""


class DeleteIncidentComment(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteIntegrationKey(sgqlc.types.Type):
    """Delete an integration key"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """True if the key was deleted, false otherwise"""


class DeleteIntegrationMutation(sgqlc.types.Type):
    """Delete an integration and all its contained connections"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteJiraIntegration(sgqlc.types.Type):
    """Delete a Jira integration"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteLineageNode(sgqlc.types.Type):
    """Delete a lineage node and any lineage edges connected to it."""

    __schema__ = schema
    __field_names__ = ("objects_deleted", "nodes_deleted", "edges_deleted")
    objects_deleted = sgqlc.types.Field(Int, graphql_name="objectsDeleted")
    """Total number of objects (nodes + edges) deleted"""

    nodes_deleted = sgqlc.types.Field(Int, graphql_name="nodesDeleted")
    """Total number of nodes deleted"""

    edges_deleted = sgqlc.types.Field(Int, graphql_name="edgesDeleted")
    """Total number of edges deleted"""


class DeleteLineageNodeBlockPattern(sgqlc.types.Type):
    """Delete a lineage node block pattern."""

    __schema__ = schema
    __field_names__ = ("pattern",)
    pattern = sgqlc.types.Field("LineageNodeBlockPattern", graphql_name="pattern")


class DeleteLineageNodeCollapsingRule(sgqlc.types.Type):
    """Delete a lineage node collapsing rule"""

    __schema__ = schema
    __field_names__ = ("rule",)
    rule = sgqlc.types.Field("LineageNodeCollapsingRule", graphql_name="rule")


class DeleteLineageNodeReplacementRule(sgqlc.types.Type):
    """Delete a lineage node replacement rule"""

    __schema__ = schema
    __field_names__ = ("rule",)
    rule = sgqlc.types.Field("LineageNodeReplacementRule", graphql_name="rule")


class DeleteLogsIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteMcpIntegrationKey(sgqlc.types.Type):
    """Delete an MCP integration key created by the current user"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """True if the key was deleted, false otherwise"""


class DeleteMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteMonitorComment(sgqlc.types.Type):
    """Deletes a monitor comment."""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")


class DeleteMonitorLabel(sgqlc.types.Type):
    """Delete a monitor label"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """True if the monitor label was deleted"""


class DeleteMonitorTag(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteMonitors(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteMonteCarloConfigTemplate(sgqlc.types.Type):
    """Delete a Monte Carlo Config Template"""

    __schema__ = schema
    __field_names__ = ("response",)
    response = sgqlc.types.Field("MonteCarloConfigTemplateDeleteResponse", graphql_name="response")
    """Response"""


class DeleteNotificationSetting(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Int, graphql_name="deleted")


class DeleteObjectProperty(sgqlc.types.Type):
    """Delete properties (tags) for objects (e.g. tables, fields, etc.)"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteOpsgenieIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """If the integration was deleted"""


class DeletePagerDutyServiceIntegration(sgqlc.types.Type):
    """Delete a PagerDuty service integration"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteRecipientName(sgqlc.types.Type):
    """Create or update a recipient's custom name"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteSamlIdentityProvider(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("account",)
    account = sgqlc.types.Field(Account, graphql_name="account")


class DeleteServiceNowIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeleteStreamingClusterMutation(sgqlc.types.Type):
    """Delete a streaming clusters, and connections on this cluster."""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteStreamingSystemMutation(sgqlc.types.Type):
    """Delete a streaming system. This will delete all clusters within
    the streaming system as well.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteTableMonitor(sgqlc.types.Type):
    """Delete a table monitor"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")


class DeleteUnifiedUserAssignment(sgqlc.types.Type):
    """Associate a UnifiedUser with a CatalogObject"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DeleteUserInvite(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class DeleteWebexIntegration(sgqlc.types.Type):
    """Delete a Webex integration"""

    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")


class DeltaLog(sgqlc.types.Type):
    """Represents a single entry in the table's Delta History"""

    __schema__ = schema
    __field_names__ = ("version", "timestamp", "user_name", "operation", "operation_metrics")
    version = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="version")
    """Table version generated by the operation."""

    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")
    """When this version was committed."""

    user_name = sgqlc.types.Field(String, graphql_name="userName")
    """Name of the user that ran the operation."""

    operation = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="operation")
    """Name of the operation."""

    operation_metrics = sgqlc.types.Field(
        sgqlc.types.non_null(JSONString), graphql_name="operationMetrics"
    )
    """Metrics of the operation (for example, number of rows and files
    modified).
    """


class DeltaLogConnection(sgqlc.types.relay.Connection):
    """Describes a page of DeltaLog results"""

    __schema__ = schema
    __field_names__ = ("edges", "page_info")
    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DeltaLogConnectionEdge")), graphql_name="edges"
    )

    page_info = sgqlc.types.Field(
        sgqlc.types.non_null("DeltaLogConnectionPageInfo"), graphql_name="pageInfo"
    )
    """Holds details of the current results page"""


class DeltaLogConnectionEdge(sgqlc.types.Type):
    """Describes each item in a paginated list of Delta Log results"""

    __schema__ = schema
    __field_names__ = ("cursor", "node")
    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A consistent identifier for each operation in the results list"""

    node = sgqlc.types.Field(sgqlc.types.non_null(DeltaLog), graphql_name="node")
    """The Delta Log object representing a single operation"""


class DeltaLogConnectionPageInfo(sgqlc.types.Type):
    """Information about the current page of Delta Log results"""

    __schema__ = schema
    __field_names__ = ("end_cursor", "has_next_page")
    end_cursor = sgqlc.types.Field(String, graphql_name="endCursor")
    """The last edge's identifier, can be passed as after argument"""

    has_next_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasNextPage")
    """Whether there are more results to be fetched"""


class DeploymentInfo(sgqlc.types.Type):
    """Deployment environment information"""

    __schema__ = schema
    __field_names__ = (
        "aws_account_id",
        "aws_region",
        "tenant_id",
        "deployment_type",
        "integration_gateway_url",
    )
    aws_account_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="awsAccountId")
    """AWS Account ID"""

    aws_region = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="awsRegion")
    """AWS Region"""

    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")
    """Tenant ID"""

    deployment_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="deploymentType")
    """Environment Deployment Type"""

    integration_gateway_url = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationGatewayUrl"
    )
    """Integration Gateway URL"""


class DerivedTablePartialLineage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "columns", "source_column_used_as_non_selected", "display_name")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Derived destination table's mcon"""

    columns = sgqlc.types.Field(sgqlc.types.list_of("SourceColumn"), graphql_name="columns")
    """A list of columns in the derived table, that are derived from some
    source
    """

    source_column_used_as_non_selected = sgqlc.types.Field(
        Boolean, graphql_name="sourceColumnUsedAsNonSelected"
    )
    """Indicates whether the input source column is used as a non
    selected column in the query that derives the current table
    """

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Display name for BI tables"""


class DerivedTablesLineageResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "source_column", "destinations", "is_last_page", "cursor")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Source table mcon"""

    source_column = sgqlc.types.Field(String, graphql_name="sourceColumn")
    """Source column"""

    destinations = sgqlc.types.Field(
        sgqlc.types.list_of(DerivedTablePartialLineage), graphql_name="destinations"
    )
    """Derived tables and their columns that are influenced by the source
    col
    """

    is_last_page = sgqlc.types.Field(Boolean, graphql_name="isLastPage")
    """Indicates whether this response the the last page of response"""

    cursor = sgqlc.types.Field(String, graphql_name="cursor")
    """Cursor for getting the next page of results"""


class DirectedGraph(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("vertices", "edges")
    vertices = sgqlc.types.Field(String, graphql_name="vertices")

    edges = sgqlc.types.Field(String, graphql_name="edges")


class DisableFreshnessTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class DisableMetadataEvents(sgqlc.types.Type):
    """Disable collection of metadata via S3 events"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DisableQueryLogEvents(sgqlc.types.Type):
    """Disable collection of query logs via S3 events"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class DisableUCSTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class DisableUser(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("user",)
    user = sgqlc.types.Field("User", graphql_name="user")


class DisableVolumeChangeTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class DisplayableFieldValueType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "field_name",
        "value_as_string",
        "value_as_string_array",
        "linked_mcon",
        "linked_mcon_array",
    )
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")

    value_as_string = sgqlc.types.Field(String, graphql_name="valueAsString")

    value_as_string_array = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="valueAsStringArray"
    )

    linked_mcon = sgqlc.types.Field(String, graphql_name="linkedMcon")

    linked_mcon_array = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="linkedMconArray"
    )


class DomainOutput(sgqlc.types.Type):
    """Domain configuration"""

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "name",
        "description",
        "created_by_email",
        "domain_tag",
        "assignments",
        "excluded_assignments",
        "tags",
        "excluded_tags",
        "assignments_with_properties",
        "excluded_assignments_with_properties",
        "obj_assignment_update_time",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """Domain UUID"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Domain name"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Domain description"""

    created_by_email = sgqlc.types.Field(String, graphql_name="createdByEmail")
    """Domain created by email address"""

    domain_tag = sgqlc.types.Field(String, graphql_name="domainTag")
    """The domain's tag representation"""

    assignments = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="assignments")
    """Objects assigned to domain (as MCONs)"""

    excluded_assignments = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="excludedAssignments"
    )
    """Objects excluded from domain (as MCONs)"""

    tags = sgqlc.types.Field(sgqlc.types.list_of("TagKeyValuePairOutput"), graphql_name="tags")
    """Filter by tag key/value pairs for tables."""

    excluded_tags = sgqlc.types.Field(
        sgqlc.types.list_of("TagKeyValuePairOutput"), graphql_name="excludedTags"
    )
    """Filter out by tag key/value pairs for tables."""

    assignments_with_properties = sgqlc.types.Field(
        sgqlc.types.list_of(AssignmentWithProperties), graphql_name="assignmentsWithProperties"
    )
    """Objects assigned to domains and their properties"""

    excluded_assignments_with_properties = sgqlc.types.Field(
        sgqlc.types.list_of(AssignmentWithProperties),
        graphql_name="excludedAssignmentsWithProperties",
    )
    """Objects excluded from domains and their properties"""

    obj_assignment_update_time = sgqlc.types.Field(DateTime, graphql_name="objAssignmentUpdateTime")
    """Last update time for object assignments cause by domain changes
    (as opposed to catalog changes)
    """


class DomainRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "name")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """Domain UUID"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Domain label"""


class DomainRestrictionConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("DomainRestrictionEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class DomainRestrictionEdge(sgqlc.types.Type):
    """A Relay edge containing a `DomainRestriction` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("DomainRestriction", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class DownstreamBI(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("node_id", "full_table_id", "downstream_bi")
    node_id = sgqlc.types.Field(String, graphql_name="nodeId")

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    downstream_bi = sgqlc.types.Field(sgqlc.types.list_of(BiLineage), graphql_name="downstreamBi")


class DownstreamImpactRadiusSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_users_affected", "total_reports_affected")
    total_users_affected = sgqlc.types.Field(Int, graphql_name="totalUsersAffected")
    """Number of users affected"""

    total_reports_affected = sgqlc.types.Field(Int, graphql_name="totalReportsAffected")
    """Number of reports affected"""


class DownstreamReport(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "display_name",
        "report_type",
        "object_id",
        "owner_id",
        "is_custom",
        "importance_score",
        "tableau_metadata",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of the report."""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Display name of the report"""

    report_type = sgqlc.types.Field(String, graphql_name="reportType")
    """Type of the report"""

    object_id = sgqlc.types.Field(String, graphql_name="objectId")
    """ID of the object"""

    owner_id = sgqlc.types.Field(String, graphql_name="ownerId")
    """ID of the owner of this object"""

    is_custom = sgqlc.types.Field(Boolean, graphql_name="isCustom")
    """Indicates whether this is a custom lineage node (created by a
    user)
    """

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """Importance score of the report"""

    tableau_metadata = sgqlc.types.Field("TableauMetadata", graphql_name="tableauMetadata")
    """Metadata for Tableau objects"""


class DownstreamReportOwners(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("owner_ids", "has_next_page", "limit", "offset")
    owner_ids = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="ownerIds"
    )
    """Owner ID of a BI report"""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """Whether more pages of results exist. Used for pagination."""

    limit = sgqlc.types.Field(Int, graphql_name="limit")
    """Limit results returned"""

    offset = sgqlc.types.Field(Int, graphql_name="offset")
    """Offset when paging"""


class DownstreamReportTypes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("downstream_report_types",)
    downstream_report_types = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="downstreamReportTypes"
    )
    """List of distinct downstream report types."""


class DownstreamReports(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("downstream_reports", "limit", "offset", "has_next_page")
    downstream_reports = sgqlc.types.Field(
        sgqlc.types.list_of(DownstreamReport), graphql_name="downstreamReports"
    )
    """List of downstream reports"""

    limit = sgqlc.types.Field(Int, graphql_name="limit")
    """Limit results returned"""

    offset = sgqlc.types.Field(Int, graphql_name="offset")
    """Offset when paging"""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """Whether more pages of results exist. Used for pagination."""


class Dynamic(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("min", "max", "reason")
    min = sgqlc.types.Field(Float, graphql_name="min")
    """Deprecated: Minimum threshold"""

    max = sgqlc.types.Field(Float, graphql_name="max")
    """Deprecated: Maximum threshold"""

    reason = sgqlc.types.Field(String, graphql_name="reason")
    """Explanation if min/max is missing"""


class ETLJobOrTaskSearchResult(sgqlc.types.Type):
    """Search result for ETL jobs and tasks"""

    __schema__ = schema
    __field_names__ = ("mcon", "name", "etl_type", "asset_type")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Monte Carlo full identifier for an entity"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the job or task"""

    etl_type = sgqlc.types.Field(sgqlc.types.non_null(EtlType), graphql_name="etlType")
    """ETL type (airflow, databricks, azure-data-factory, dbt)"""

    asset_type = sgqlc.types.Field(sgqlc.types.non_null(ETLAssetType), graphql_name="assetType")
    """Whether this is a job or task"""


class ETLJobsConnectionTypeConnection(sgqlc.types.relay.Connection):
    """Etl Jobs"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges", "edge_count", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("ETLJobsConnectionTypeEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")
    """Total number of edges returned (page count)"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of edges matching filter (total count)"""


class ETLJobsConnectionTypeEdge(sgqlc.types.Type):
    """A Relay edge containing a `ETLJobsConnectionType` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("ETLJobUnionType", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class ETLJobsType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("jobs", "has_next_page")
    jobs = sgqlc.types.Field(sgqlc.types.list_of("ETLJobUnionType"), graphql_name="jobs")
    """ETL Jobs list"""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """Boolean indicating if there's a next page based on limit/offset"""


class ETLTasksType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tasks", "has_next_page")
    tasks = sgqlc.types.Field(sgqlc.types.list_of("ETLTaskUnionType"), graphql_name="tasks")
    """ETL Tasks list"""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """Boolean indicating if there's a next page based on limit/offset"""


class EmptyDataCollector(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "customer_aws_region")
    uuid = sgqlc.types.Field(String, graphql_name="uuid")

    customer_aws_region = sgqlc.types.Field(String, graphql_name="customerAwsRegion")


class EnableAutomatedFreshnessTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class EnableAutomatedUCSTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class EnableAutomatedVolumeChangeTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class EnableExplicitFreshnessTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class EnableExplicitUCSTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class EnableExplicitVolumeChangeTableMonitor(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""


class Error(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("code", "message", "id", "extra", "path")
    code = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="code")

    message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message")

    id = sgqlc.types.Field(String, graphql_name="id")

    extra = sgqlc.types.Field(GenericScalar, graphql_name="extra")

    path = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="path")


class EtlContainer(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "deleted_at",
        "account",
        "uuid",
        "data_collector",
        "type",
        "name",
        "is_synthetic",
        "last_webhook_received",
        "connections",
        "incidents",
        "events",
        "airflowdagmodel_set",
        "airflowtaskmodel_set",
        "airflowdagrunmodel_set",
        "airflowtaskrunmodel_set",
        "databricksjobmodel_set",
        "databrickstaskmodel_set",
        "databricksjobrunmodel_set",
        "databrickstaskrunmodel_set",
        "adfjobmodel_set",
        "adftaskmodel_set",
        "adfjobrunmodel_set",
        "adftaskrunmodel_set",
        "job_count",
        "webhook_status",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    data_collector = sgqlc.types.Field(DataCollector, graphql_name="dataCollector")

    type = sgqlc.types.Field(EtlType, graphql_name="type")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """A friendly name for this etl container"""

    is_synthetic = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSynthetic")
    """Whether this etl container is created as a result of another
    connection
    """

    last_webhook_received = sgqlc.types.Field(DateTime, graphql_name="lastWebhookReceived")
    """The timestamp when the last webhook event was received"""

    connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connections",
    )

    incidents = sgqlc.types.Field(
        sgqlc.types.non_null("IncidentConnection"),
        graphql_name="incidents",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    events = sgqlc.types.Field(
        sgqlc.types.non_null("EventConnection"),
        graphql_name="events",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    airflowdagmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowDagConnection),
        graphql_name="airflowdagmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the pipeline

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    airflowtaskmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowTaskConnection),
        graphql_name="airflowtaskmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the pipeline

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    airflowdagrunmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowDagRunConnection),
        graphql_name="airflowdagrunmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    airflowtaskrunmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowTaskRunConnection),
        graphql_name="airflowtaskrunmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    databricksjobmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksJobConnection),
        graphql_name="databricksjobmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the pipeline

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    databrickstaskmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksTaskConnection),
        graphql_name="databrickstaskmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the pipeline

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    databricksjobrunmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksJobRunConnection),
        graphql_name="databricksjobrunmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    databrickstaskrunmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksTaskRunConnection),
        graphql_name="databrickstaskrunmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    adfjobmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AdfJobConnection),
        graphql_name="adfjobmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the pipeline

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    adftaskmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AdfTaskConnection),
        graphql_name="adftaskmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the pipeline

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    adfjobrunmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AdfJobRunConnection),
        graphql_name="adfjobrunmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    adftaskrunmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(AdfTaskRunConnection),
        graphql_name="adftaskrunmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """ETL container associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    job_count = sgqlc.types.Field(Int, graphql_name="jobCount")
    """Number of ETL jobs in this container"""

    webhook_status = sgqlc.types.Field("WebhookStatus", graphql_name="webhookStatus")
    """Webhook status info, or null if not applicable for this
    integration type
    """


class EventConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("EventEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class EventDetectorFeedbackConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("EventDetectorFeedbackEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class EventDetectorFeedbackEdge(sgqlc.types.Type):
    """A Relay edge containing a `EventDetectorFeedback` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("EventDetectorFeedback", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class EventEdge(sgqlc.types.Type):
    """A Relay edge containing a `Event` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("Event", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class EventEvaluation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field", "function", "prompt", "output_type", "sql_expression")
    field = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="field")
    """Field evaluated"""

    function = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="function")
    """Function used in the evaluation"""

    prompt = sgqlc.types.Field(String, graphql_name="prompt")
    """Prompt used in the evaluation"""

    output_type = sgqlc.types.Field(String, graphql_name="outputType")
    """Output type used in the evaluation"""

    sql_expression = sgqlc.types.Field(String, graphql_name="sqlExpression")
    """SQL expression used in the evaluation"""


class EventGroup(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("group_key", "group_metadata", "group_events")
    group_key = sgqlc.types.Field(sgqlc.types.non_null("EventGroupKey"), graphql_name="groupKey")
    """Attributes that uniquely defines an event group"""

    group_metadata = sgqlc.types.Field(
        sgqlc.types.non_null("EventGroupMetadata"), graphql_name="groupMetadata"
    )
    """Additional metadata of the event group (not used to create the
    event group)
    """

    group_events = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("Event")), graphql_name="groupEvents"
    )
    """List of events in an event group"""


class EventGroupKey(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "monitor_uuid",
        "event_type",
        "table_mcon",
        "metric",
        "query_group_hash",
        "job_mcon",
        "job_run_id",
    )
    monitor_uuid = sgqlc.types.Field(UUID, graphql_name="monitorUuid")
    """The UUID of the monitor of the grouped events"""

    event_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="eventType")
    """The type of the grouped events"""

    table_mcon = sgqlc.types.Field(String, graphql_name="tableMcon")
    """MCON of the table of the grouped events"""

    metric = sgqlc.types.Field(String, graphql_name="metric")
    """The metric type of the grouped events"""

    query_group_hash = sgqlc.types.Field(String, graphql_name="queryGroupHash")
    """Hash used to group events related to the same query"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of the job of the grouped events"""

    job_run_id = sgqlc.types.Field(String, graphql_name="jobRunId")
    """Run ID of the job/DAG of the grouped events"""


class EventGroupMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "newest_event_generated_time",
        "group_title",
        "table",
        "warehouse",
        "total_events",
    )
    newest_event_generated_time = sgqlc.types.Field(
        DateTime, graphql_name="newestEventGeneratedTime"
    )

    group_title = sgqlc.types.Field(String, graphql_name="groupTitle")

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")

    warehouse = sgqlc.types.Field("Warehouse", graphql_name="warehouse")

    total_events = sgqlc.types.Field(Int, graphql_name="totalEvents")
    """Total number of events in the event group"""


class EventMutingRule(sgqlc.types.Type):
    """Placeholder for deprecated API call"""

    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "warehouse",
        "rule_type",
        "rule",
        "is_active",
        "created_time",
        "last_update_time",
        "event_types",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null("Warehouse"), graphql_name="warehouse")

    rule_type = sgqlc.types.Field(
        sgqlc.types.non_null(EventMutingRuleModelRuleType), graphql_name="ruleType"
    )

    rule = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="rule")

    is_active = sgqlc.types.Field(Boolean, graphql_name="isActive")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    last_update_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="lastUpdateTime"
    )

    event_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="eventTypes"
    )


class EventOnbardingConfig(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("account_uuid", "config")
    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")

    config = sgqlc.types.Field(JSONString, graphql_name="config")
    """Onboarding Config meant to be shared between customers and MC"""


class EventRcaData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("event_uuid", "rcas")
    event_uuid = sgqlc.types.Field(UUID, graphql_name="eventUuid")

    rcas = sgqlc.types.Field(sgqlc.types.list_of("ExtendedRca"), graphql_name="rcas")


class EventRcaStatus(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "event", "rca", "set_ts", "reason", "rca_module", "rca_job_uuid")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    event = sgqlc.types.Field(sgqlc.types.non_null("Event"), graphql_name="event")

    rca = sgqlc.types.Field("RcaJob", graphql_name="rca")

    set_ts = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="setTs")

    reason = sgqlc.types.Field(
        sgqlc.types.non_null(EventRcaStatusModelReason), graphql_name="reason"
    )
    """Reason why RCA was assigned a specific status."""

    rca_module = sgqlc.types.Field(String, graphql_name="rcaModule")
    """The RCA module that detected the failure reason"""

    rca_job_uuid = sgqlc.types.Field(UUID, graphql_name="rcaJobUuid")
    """UUID of the RCA job associated with the status"""


class EventRcaStatusModelType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "event", "rca", "set_ts", "reason", "rca_module")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    event = sgqlc.types.Field(sgqlc.types.non_null("Event"), graphql_name="event")

    rca = sgqlc.types.Field("RcaJob", graphql_name="rca")

    set_ts = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="setTs")

    reason = sgqlc.types.Field(
        sgqlc.types.non_null(EventRcaStatusModelReason), graphql_name="reason"
    )
    """Reason why RCA was assigned a specific status."""

    rca_module = sgqlc.types.Field(String, graphql_name="rcaModule")
    """The RCA module that detected the failure reason"""


class EventStateSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "open",
        "false_positive",
        "no_action_required",
        "notified",
        "resolved",
        "user_resolved",
        "system_resolved",
        "muted",
        "stale",
    )
    open = sgqlc.types.Field(Int, graphql_name="open")

    false_positive = sgqlc.types.Field(Int, graphql_name="falsePositive")

    no_action_required = sgqlc.types.Field(Int, graphql_name="noActionRequired")

    notified = sgqlc.types.Field(Int, graphql_name="notified")

    resolved = sgqlc.types.Field(Int, graphql_name="resolved")

    user_resolved = sgqlc.types.Field(Int, graphql_name="userResolved")

    system_resolved = sgqlc.types.Field(Int, graphql_name="systemResolved")

    muted = sgqlc.types.Field(Int, graphql_name="muted")

    stale = sgqlc.types.Field(Int, graphql_name="stale")


class EventTopology(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("event", "upstream")
    event = sgqlc.types.Field("Event", graphql_name="event")
    """Reference to an event"""

    upstream = sgqlc.types.Field(sgqlc.types.list_of("Event"), graphql_name="upstream")
    """List of events immediately upstream"""


class EventTypeSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "schema_change",
        "fresh_anom",
        "unchanged_size_anom",
        "json_schema_change",
        "delete_table",
        "size_anom",
        "size_diff",
        "metric_anom",
        "metric_comparison_anom",
        "agent_anom",
        "custom_rule_anom",
        "validation_anom",
        "dist_anom",
        "query_runtime_anom",
        "query_performance_anom",
        "dbt_model_error",
        "dbt_test_failure",
        "dbt_test_warning",
        "dbt_snapshot_error",
        "dbt_seed_error",
        "airflow_dag_failure",
        "databricks_job_failure",
        "adf_job_failure",
        "rule_run_failure",
        "comparison_rule_anom",
    )
    schema_change = sgqlc.types.Field(Int, graphql_name="schemaChange")

    fresh_anom = sgqlc.types.Field(Int, graphql_name="freshAnom")

    unchanged_size_anom = sgqlc.types.Field(Int, graphql_name="unchangedSizeAnom")

    json_schema_change = sgqlc.types.Field(Int, graphql_name="jsonSchemaChange")

    delete_table = sgqlc.types.Field(Int, graphql_name="deleteTable")

    size_anom = sgqlc.types.Field(Int, graphql_name="sizeAnom")

    size_diff = sgqlc.types.Field(Int, graphql_name="sizeDiff")

    metric_anom = sgqlc.types.Field(Int, graphql_name="metricAnom")

    metric_comparison_anom = sgqlc.types.Field(Int, graphql_name="metricComparisonAnom")

    agent_anom = sgqlc.types.Field(Int, graphql_name="agentAnom")

    custom_rule_anom = sgqlc.types.Field(Int, graphql_name="customRuleAnom")

    validation_anom = sgqlc.types.Field(Int, graphql_name="validationAnom")

    dist_anom = sgqlc.types.Field(Int, graphql_name="distAnom")

    query_runtime_anom = sgqlc.types.Field(Int, graphql_name="queryRuntimeAnom")

    query_performance_anom = sgqlc.types.Field(Int, graphql_name="queryPerformanceAnom")

    dbt_model_error = sgqlc.types.Field(Int, graphql_name="dbtModelError")

    dbt_test_failure = sgqlc.types.Field(Int, graphql_name="dbtTestFailure")

    dbt_test_warning = sgqlc.types.Field(Int, graphql_name="dbtTestWarning")

    dbt_snapshot_error = sgqlc.types.Field(Int, graphql_name="dbtSnapshotError")

    dbt_seed_error = sgqlc.types.Field(Int, graphql_name="dbtSeedError")

    airflow_dag_failure = sgqlc.types.Field(Int, graphql_name="airflowDagFailure")

    databricks_job_failure = sgqlc.types.Field(Int, graphql_name="databricksJobFailure")

    adf_job_failure = sgqlc.types.Field(Int, graphql_name="adfJobFailure")

    rule_run_failure = sgqlc.types.Field(Int, graphql_name="ruleRunFailure")

    comparison_rule_anom = sgqlc.types.Field(Int, graphql_name="comparisonRuleAnom")


class ExecDashboardDataColumn(sgqlc.types.Type):
    """A column for a table."""

    __schema__ = schema
    __field_names__ = ("name", "type")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name associated with the column, can be used to identify it."""

    type = sgqlc.types.Field(sgqlc.types.non_null(DataColumnTypes), graphql_name="type")
    """Data type of the values included in the column."""


class ExecDashboardDataPoint(sgqlc.types.Type):
    """A single measure/data point for a metric."""

    __schema__ = schema
    __field_names__ = ("value", "period_start", "dimension", "children")
    value = sgqlc.types.Field(Float, graphql_name="value")
    """Value of data point."""

    period_start = sgqlc.types.Field(DateTime, graphql_name="periodStart")
    """Start of period for data point, for time series."""

    dimension = sgqlc.types.Field(String, graphql_name="dimension")
    """Dimension of data point, for category series."""

    children = sgqlc.types.Field(
        sgqlc.types.list_of("ExecDashboardDataPoint"), graphql_name="children"
    )


class ExecDashboardDataRow(sgqlc.types.Type):
    """A row with values for each column."""

    __schema__ = schema
    __field_names__ = ("values",)
    values = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="values")
    """Values for each column in the row."""


class ExecDashboardMetric(sgqlc.types.Type):
    """A set of data points (or single data point) that is a named
    measure.
    """

    __schema__ = schema
    __field_names__ = ("metric", "data_points", "has_error")
    metric = sgqlc.types.Field(sgqlc.types.non_null(ExecDashboardMetrics), graphql_name="metric")
    """Metric identifier."""

    data_points = sgqlc.types.Field(
        sgqlc.types.list_of(ExecDashboardDataPoint), graphql_name="dataPoints"
    )
    """Data points. May only be one for single-value metrics."""

    has_error = sgqlc.types.Field(Boolean, graphql_name="hasError")
    """If true, indicates an error occurred trying to get metric data."""


class ExecDashboardTable(sgqlc.types.Type):
    """A table with measured values."""

    __schema__ = schema
    __field_names__ = ("table", "data_columns", "data_rows", "is_visible", "has_error")
    table = sgqlc.types.Field(sgqlc.types.non_null(ExecDashboardTables), graphql_name="table")
    """Table identifier."""

    data_columns = sgqlc.types.Field(
        sgqlc.types.list_of(ExecDashboardDataColumn), graphql_name="dataColumns"
    )
    """Column definitions."""

    data_rows = sgqlc.types.Field(
        sgqlc.types.list_of(ExecDashboardDataRow), graphql_name="dataRows"
    )
    """Row values."""

    is_visible = sgqlc.types.Field(Boolean, graphql_name="isVisible")
    """If true, indicates that the table must be shown, otherwise it
    should be hidden.
    """

    has_error = sgqlc.types.Field(Boolean, graphql_name="hasError")
    """If true, indicates an error occurred trying to get metric data."""


class ExplanationDataPointType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "query_id",
        "timestamp",
        "execution_time",
        "baseline_metric",
        "pct_increase_over_baseline_upper_threshold",
        "is_breach",
    )
    query_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="queryId")
    """Query ID of query execution"""

    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")
    """Timestamp of query"""

    execution_time = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="executionTime")
    """Execution time of query"""

    baseline_metric = sgqlc.types.Field(Float, graphql_name="baselineMetric")
    """Historical baseline metric"""

    pct_increase_over_baseline_upper_threshold = sgqlc.types.Field(
        Float, graphql_name="pctIncreaseOverBaselineUpperThreshold"
    )
    """Upper threshold of % increase over historical baseline metric"""

    is_breach = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isBreach")
    """True if this query execution breaches monitor."""


class ExplanatoryFieldMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("candidates",)
    candidates = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="candidates")
    """Fields which can be used as explanatory"""


class ExtendedDataSource(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "data_source",
        "dw_id",
        "where_condition",
        "segments",
        "connection_uuid",
        "timeout",
        "uuid",
        "segment_count_hint",
    )
    data_source = sgqlc.types.Field(
        sgqlc.types.non_null(DataSourceInputInterface), graphql_name="dataSource"
    )
    """Data source can be table or sql."""

    dw_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dwId")
    """Warehouse of the data source."""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """Where condition used for table data source."""

    segments = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface)), graphql_name="segments"
    )
    """segments for data source."""

    connection_uuid = sgqlc.types.Field(UUID, graphql_name="connectionUuid")
    """Connection UUID for the data source."""

    timeout = sgqlc.types.Field(Int, graphql_name="timeout")
    """Timeout for the SQL query."""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the data source."""

    segment_count_hint = sgqlc.types.Field(Int, graphql_name="segmentCountHint")
    """Segment count from the previous run."""


class FHEvent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "event_uuid",
        "alert_uuid",
        "where_condition",
        "metric",
        "field",
        "value",
        "date",
        "lower_threshold",
        "upper_threshold",
        "threshold_type",
        "comparison_operator",
        "auto_operator",
        "custom_metric_display_name",
        "custom_metric_sql_expression",
        "historical_mean",
        "detector_feedback",
        "agg_time_interval",
        "event_type",
        "time_series_uuid",
        "parent_time_series_uuid",
    )
    event_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="eventUuid")
    """UUID of the anomaly event"""

    alert_uuid = sgqlc.types.Field(UUID, graphql_name="alertUuid")
    """UUID of the alert associated with this event"""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """Segmented where condition"""

    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")
    """Metric name"""

    field = sgqlc.types.Field(String, graphql_name="field")
    """Field name"""

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")
    """Value"""

    date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="date")
    """Timestamp of the event"""

    lower_threshold = sgqlc.types.Field(Float, graphql_name="lowerThreshold")
    """Lower threshold"""

    upper_threshold = sgqlc.types.Field(Float, graphql_name="upperThreshold")
    """Upper threshold"""

    threshold_type = sgqlc.types.Field(String, graphql_name="thresholdType")
    """Threshold type (explicit or auto)"""

    comparison_operator = sgqlc.types.Field(
        CustomRuleComparisonOperator, graphql_name="comparisonOperator"
    )
    """Threshold comparison operator"""

    auto_operator = sgqlc.types.Field(AutoOperator, graphql_name="autoOperator")
    """Operator used (when using automatic operators)"""

    custom_metric_display_name = sgqlc.types.Field(String, graphql_name="customMetricDisplayName")
    """Display name of the custom metric"""

    custom_metric_sql_expression = sgqlc.types.Field(
        String, graphql_name="customMetricSqlExpression"
    )
    """SQL expression evaluated for the custom metric"""

    historical_mean = sgqlc.types.Field(Float, graphql_name="historicalMean")
    """Historical mean value"""

    detector_feedback = sgqlc.types.Field("EventDetectorFeedback", graphql_name="detectorFeedback")
    """Feedback for the detector about the event"""

    agg_time_interval = sgqlc.types.Field(MonitorAggTimeInterval, graphql_name="aggTimeInterval")
    """Aggregation time interval. When not using a hourly interval, the
    timecomponent of the event timestamp should be ignored.
    """

    event_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="eventType")
    """Type of the event"""

    time_series_uuid = sgqlc.types.Field(UUID, graphql_name="timeSeriesUuid")
    """Time series UUID"""

    parent_time_series_uuid = sgqlc.types.Field(UUID, graphql_name="parentTimeSeriesUuid")
    """Parent time series UUID"""


class FHEvents(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("events", "total_count")
    events = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FHEvent))),
        graphql_name="events",
    )
    """List of events"""

    total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount")
    """Total number of results available"""


class FHEventsFilterValues(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("values", "total_count")
    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="values",
    )
    """List of values"""

    total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount")
    """Total number of results available"""


class FHNumericRcaResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("rca",)
    rca = sgqlc.types.Field(sgqlc.types.list_of("FHNumericResult"), graphql_name="rca")


class FHNumericResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "metric_name",
        "metric_field_name",
        "explanatory_field_name",
        "explanatory_field_value",
        "normal_row_ratio",
        "anomalous_row_ratio",
        "normal_metric_value",
        "anomalous_metric_value",
        "explainability1",
        "explainability2",
        "correlation",
    )
    metric_name = sgqlc.types.Field(String, graphql_name="metricName")
    """The metric which we ran the correlation for (i.e. mean, p80, etc.)"""

    metric_field_name = sgqlc.types.Field(String, graphql_name="metricFieldName")
    """The name of the field we ran the correlation for"""

    explanatory_field_name = sgqlc.types.Field(String, graphql_name="explanatoryFieldName")
    """The name of the column in which a value is correlated with the
    anomalous rows
    """

    explanatory_field_value = sgqlc.types.Field(String, graphql_name="explanatoryFieldValue")
    """The value correlated with the anomalous rows"""

    normal_row_ratio = sgqlc.types.Field(Float, graphql_name="normalRowRatio")
    """The ratio of rows out of total rows for the explanatory value
    prior to the anomaly
    """

    anomalous_row_ratio = sgqlc.types.Field(Float, graphql_name="anomalousRowRatio")
    """The ratio of rows out of total rows for the explanatory value in
    the anomalous rows
    """

    normal_metric_value = sgqlc.types.Field(Float, graphql_name="normalMetricValue")
    """The value of the relevant metric prior to the anomaly"""

    anomalous_metric_value = sgqlc.types.Field(Float, graphql_name="anomalousMetricValue")
    """The value of metric in the anomalous rows"""

    explainability1 = sgqlc.types.Field(Float, graphql_name="explainability1")
    """Explainability 1 score"""

    explainability2 = sgqlc.types.Field(Float, graphql_name="explainability2")
    """Explainability 2 score"""

    correlation = sgqlc.types.Field(String, graphql_name="correlation")
    """high or low correlation found on field"""


class FacetEntry(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("key", "count", "display")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Key of facet entry"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Number of documents that contain key"""

    display = sgqlc.types.Field(String, graphql_name="display")
    """Display value of the facet entry"""


class FacetResultType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value", "display_name", "count")
    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """Field value"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Display name"""

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")
    """Count"""


class FacetResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("facet_type", "entries")
    facet_type = sgqlc.types.Field(FacetType, graphql_name="facetType")
    """Facet type"""

    entries = sgqlc.types.Field(sgqlc.types.list_of(FacetEntry), graphql_name="entries")
    """Facet entries"""


class FieldChange(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field", "friendly_name", "scalar_change", "many_to_many_change")
    field = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="field")
    """The name of the changed field"""

    friendly_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="friendlyName")
    """Friendly name of the changed field"""

    scalar_change = sgqlc.types.Field("ScalarChange", graphql_name="scalarChange")
    """Change to scalar field"""

    many_to_many_change = sgqlc.types.Field("ManyToManyChange", graphql_name="manyToManyChange")
    """Change to M2M field"""


class FieldConfig(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("type", "count", "field")
    type = sgqlc.types.Field(sgqlc.types.non_null(FieldConfigType), graphql_name="type")

    count = sgqlc.types.Field(Int, graphql_name="count")

    field = sgqlc.types.Field(String, graphql_name="field")


class FieldDistRcaData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_field", "anom_time", "explanatory_field", "val")
    time_field = sgqlc.types.Field(String, graphql_name="timeField")
    """Table field which serves as a time axis"""

    anom_time = sgqlc.types.Field(DateTime, graphql_name="anomTime")
    """Time when the anomaly occurred"""

    explanatory_field = sgqlc.types.Field(String, graphql_name="explanatoryField")
    """Table field containing the explanatory value"""

    val = sgqlc.types.Field(String, graphql_name="val")
    """Explanatory value used in the analysis"""


class FieldDistRcaResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("rca", "plot_data", "low_card_fields_wo_rca", "available_fields")
    rca = sgqlc.types.Field(sgqlc.types.list_of(FieldDistRcaData), graphql_name="rca")

    plot_data = sgqlc.types.Field(
        sgqlc.types.list_of("RcaPlotData"),
        graphql_name="plotData",
        args=sgqlc.types.ArgDict(
            (("field_name", sgqlc.types.Arg(String, graphql_name="fieldName", default=None)),)
        ),
    )
    """Arguments:

    * `field_name` (`String`)None
    """

    low_card_fields_wo_rca = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="lowCardFieldsWoRca"
    )

    available_fields = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="availableFields"
    )


class FieldDownstreamBi(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "bi_account_id",
        "bi_identifier",
        "bi_name",
        "bi_type",
        "bi_node_id",
        "last_seen",
    )
    bi_account_id = sgqlc.types.Field(String, graphql_name="biAccountId")

    bi_identifier = sgqlc.types.Field(String, graphql_name="biIdentifier")

    bi_name = sgqlc.types.Field(String, graphql_name="biName")

    bi_type = sgqlc.types.Field(String, graphql_name="biType")

    bi_node_id = sgqlc.types.Field(String, graphql_name="biNodeId")

    last_seen = sgqlc.types.Field(DateTime, graphql_name="lastSeen")


class FieldHealth(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("lower", "upper", "status", "reason")
    lower = sgqlc.types.Field(Float, graphql_name="lower")
    """Field health lower threshold"""

    upper = sgqlc.types.Field(Float, graphql_name="upper")
    """Field health upper threshold"""

    status = sgqlc.types.Field(DetectorStatus, graphql_name="status")
    """Status of the FH detection"""

    reason = sgqlc.types.Field(String, graphql_name="reason")
    """Reason for not providing FH thresholds"""


class FieldHealthSampling(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "columns",
        "rows",
        "matches",
        "sampling_disabled",
        "next_file_index",
        "total_samples_size",
        "normal_records_query",
        "anomalous_records_query",
    )
    columns = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="columns")

    rows = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.list_of(String)), graphql_name="rows")

    matches = sgqlc.types.Field(sgqlc.types.list_of(ConditionMatches), graphql_name="matches")

    sampling_disabled = sgqlc.types.Field(Boolean, graphql_name="samplingDisabled")

    next_file_index = sgqlc.types.Field(Int, graphql_name="nextFileIndex")
    """Next file index to retrieve."""

    total_samples_size = sgqlc.types.Field(Int, graphql_name="totalSamplesSize")
    """Total number of samples retrieved."""

    normal_records_query = sgqlc.types.Field(String, graphql_name="normalRecordsQuery")
    """This is null for summary statistics such as mean, min, max, and
    percentiles
    """

    anomalous_records_query = sgqlc.types.Field(String, graphql_name="anomalousRecordsQuery")


class FieldHealthSamplingConditionsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("conditions",)
    conditions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="conditions"
    )
    """List of conditions that can be used to construct sample query."""


class FieldMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_type", "table")
    field_type = sgqlc.types.Field(String, graphql_name="fieldType")

    table = sgqlc.types.Field("TableRef", graphql_name="table")


class FieldMetricDataResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data", "sql_query", "field_name", "metric_info")
    data = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MetricMeasurement"))),
        graphql_name="data",
    )

    sql_query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlQuery")

    field_name = sgqlc.types.Field(String, graphql_name="fieldName")

    metric_info = sgqlc.types.Field(sgqlc.types.non_null("MetricInfo"), graphql_name="metricInfo")


class FieldMetricDefinition(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "display_name",
        "description",
        "category",
        "unit",
        "is_percentage",
        "field_types",
        "deprecated",
        "supports_manual_threshold",
        "supports_auto_threshold",
        "supports_auto_high_threshold",
        "supports_auto_low_threshold",
        "is_grouped",
        "is_field_level",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the field metric"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Display name of the field metric"""

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")
    """Description of the field metric"""

    category = sgqlc.types.Field(sgqlc.types.non_null(FieldMetricCategory), graphql_name="category")
    """Category of the field metric. For example, uniqueness, validity,
    etc
    """

    unit = sgqlc.types.Field(sgqlc.types.non_null("MetricUnit"), graphql_name="unit")
    """Unit of the field metric"""

    is_percentage = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPercentage")
    """Whether this field metric represents a percentage metric. For
    example, % null
    """

    field_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(FieldType)), graphql_name="fieldTypes"
    )
    """A list of field types which this metric applies to"""

    deprecated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="deprecated")
    """Indicates if the field metric was deprecated"""

    supports_manual_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsManualThreshold"
    )
    """Indicates whether the metric can be used in a Metric Monitor with
    manual thresholds
    """

    supports_auto_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsAutoThreshold"
    )
    """Indicates whether the metric can be used in a Metric Monitor with
    automatic thresholds
    """

    supports_auto_high_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsAutoHighThreshold"
    )
    """Indicates whether the metric can be used in a Metric Monitor with
    automatic thresholds (considering only anomalously high values)
    """

    supports_auto_low_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsAutoLowThreshold"
    )
    """Indicates whether the metric can be used in a Metric Monitor with
    automatic thresholds (considering only anomalously low values)
    """

    is_grouped = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isGrouped")
    """Indicates whether this metric is a collection (grouping) of other
    metrics
    """

    is_field_level = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isFieldLevel")
    """Indicates whether this metric is a field level metric"""


class FieldMetricFilterOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "operator", "value")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field to filter by"""

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleComparisonOperator), graphql_name="operator"
    )
    """Operator to filter field by"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Value to filter field by"""


class FieldMetricOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "table_mcon",
        "table_mcons",
        "field_name",
        "field_names",
        "metric_type",
        "value_list",
        "value_sql",
        "filters",
    )
    table_mcon = sgqlc.types.Field(String, graphql_name="tableMcon")
    """MCON of the table the metric is based on"""

    table_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tableMcons")
    """MCONs of the table the metric is based on"""

    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Name of the field the metric is based on"""

    field_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fieldNames")
    """Name of the fields the metric is based on"""

    metric_type = sgqlc.types.Field(
        sgqlc.types.non_null(FieldMetricType), graphql_name="metricType"
    )
    """Type of metric to compute"""

    value_list = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="valueList")
    """Values for metrics that check for cardinality"""

    value_sql = sgqlc.types.Field(String, graphql_name="valueSql")
    """Values SQL expression for metrics that check for cardinality"""

    filters = sgqlc.types.Field(
        sgqlc.types.list_of(FieldMetricFilterOutput), graphql_name="filters"
    )
    """Filters for which rows the metric is computed over"""


class FieldMetricQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sql_query",)
    sql_query = sgqlc.types.Field(String, graphql_name="sqlQuery")
    """SQL query for the metric"""


class FieldOverviewProperty(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metric_name", "display_name", "value", "metric_data_type")
    metric_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metricName")

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

    metric_data_type = sgqlc.types.Field(
        sgqlc.types.non_null(MetricDataType), graphql_name="metricDataType"
    )


class FieldOverviewResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sql_query", "properties")
    sql_query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlQuery")

    properties = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FieldOverviewProperty))),
        graphql_name="properties",
    )


class FieldQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sql_query", "variables")
    sql_query = sgqlc.types.Field(String, graphql_name="sqlQuery")
    """SQL query"""

    variables = sgqlc.types.Field(JSONString, graphql_name="variables")
    """Possible variable values for SQL query"""


class FieldQueryFilterOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "operator", "value")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field to filter by"""

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleComparisonOperator), graphql_name="operator"
    )
    """Operator to filter field by"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Value to filter field by"""


class FieldQueryParametersOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "table_mcons",
        "field_names",
        "query_type",
        "value_list",
        "value_sql",
        "filters",
    )
    table_mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="tableMcons"
    )
    """MCONs of the table the query is based on"""

    field_names = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="fieldNames"
    )
    """Name of the fields the query is based on"""

    query_type = sgqlc.types.Field(sgqlc.types.non_null(FieldQueryType), graphql_name="queryType")
    """Type of query"""

    value_list = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="valueList")
    """Values for queries that check for cardinality"""

    value_sql = sgqlc.types.Field(String, graphql_name="valueSql")
    """Values SQL expression for metrics that check for cardinality"""

    filters = sgqlc.types.Field(sgqlc.types.list_of(FieldQueryFilterOutput), graphql_name="filters")
    """Filters for which rows the query is computed over"""


class FieldTypeChange(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "new_field_type", "old_field_type")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")

    new_field_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="newFieldType")

    old_field_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="oldFieldType")


class FieldValueCorrelation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field", "value", "norm_rate", "anom_rate")
    field = sgqlc.types.Field(String, graphql_name="field")

    value = sgqlc.types.Field(String, graphql_name="value")

    norm_rate = sgqlc.types.Field(Float, graphql_name="normRate")

    anom_rate = sgqlc.types.Field(Float, graphql_name="anomRate")


class FilterPredicate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "negated")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    negated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="negated")


class FivetranConnectorConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("FivetranConnectorEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of connectors"""


class FivetranConnectorEdge(sgqlc.types.Type):
    """A Relay edge containing a `FivetranConnector` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("FivetranConnector", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class FivetranDestinationConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("FivetranDestinationEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class FivetranDestinationEdge(sgqlc.types.Type):
    """A Relay edge containing a `FivetranDestination` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("FivetranDestination", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class FlattenedLineageGraphEdges(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "directly_connected_mcons", "directly_connected_nodes")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Monte Carlo full identifier for an entity"""

    directly_connected_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="directlyConnectedMcons"
    )
    """MCONs of nodes directly connected to the entity"""

    directly_connected_nodes = sgqlc.types.Field(
        sgqlc.types.list_of("LineageGraphEdgeNode"), graphql_name="directlyConnectedNodes"
    )
    """Nodes directly connected to the entity, including edge properties"""


class Freshness(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "status",
        "expected",
        "breach",
        "reason",
        "last_update",
        "detector_threshold",
        "threshold_low",
        "threshold_medium",
        "threshold_high",
    )
    status = sgqlc.types.Field(DetectorStatus, graphql_name="status")
    """Status of the freshness detector"""

    expected = sgqlc.types.Field(Float, graphql_name="expected")
    """Deprecated: Time delta of next expected update (in seconds)"""

    breach = sgqlc.types.Field(Float, graphql_name="breach")
    """Deprecated: Time delta when a delay is considered a breach (in
    seconds)
    """

    reason = sgqlc.types.Field(String, graphql_name="reason")
    """Explanation if expected and/or breach is missing"""

    last_update = sgqlc.types.Field(DateTime, graphql_name="lastUpdate")
    """Deprecated, use getMetricsV4: Last time the table was updated"""

    detector_threshold = sgqlc.types.Field(Float, graphql_name="detectorThreshold")
    """Deprecated: The threshold calculated by the detector model"""

    threshold_low = sgqlc.types.Field(Float, graphql_name="thresholdLow")
    """The "low" level threshold calculated by the detector model"""

    threshold_medium = sgqlc.types.Field(Float, graphql_name="thresholdMedium")
    """The "medium" level threshold calculated by the detector model"""

    threshold_high = sgqlc.types.Field(Float, graphql_name="thresholdHigh")
    """The "high" level threshold calculated by the detector model"""


class FreshnessAutomatedAlertConditionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sensitivity_level",)
    sensitivity_level = sgqlc.types.Field(
        sgqlc.types.non_null(SensitivityLevels), graphql_name="sensitivityLevel"
    )
    """Sensitivity for automated thresholds"""


class FreshnessDetectorThresholdOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value",)
    value = sgqlc.types.Field(sgqlc.types.non_null("ThresholdLMHType"), graphql_name="value")
    """Thresholds in minutes"""


class FreshnessExplicitAlertConditionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "start_time",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "timezone",
        "is_auto_schedule_config",
        "threshold",
    )
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of the collection"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Collection interval in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Collection interval in crontab format"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions"""

    is_auto_schedule_config = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isAutoScheduleConfig"
    )
    """True if auto schedule configuration is used"""

    threshold = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="threshold")
    """Explicit freshness threshold in minutes"""


class FreshnessTableMonitorConfigOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "status",
        "metric",
        "most_recent_value",
        "collection_status",
        "supports_explicit_alert_condition",
        "tags",
        "data_quality_dimension",
        "alert_condition",
        "detector_threshold",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""

    status = sgqlc.types.Field(
        sgqlc.types.non_null(ConsolidatedMonitorStatusType), graphql_name="status"
    )
    """Detection status"""

    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")
    """Name of metric for which the detector is active"""

    most_recent_value = sgqlc.types.Field(Float, graphql_name="mostRecentValue")
    """Most recent value change analyzed by the detector"""

    collection_status = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionStatusOutput), graphql_name="collectionStatus"
    )
    """Collection status information"""

    supports_explicit_alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsExplicitAlertCondition"
    )
    """True if using the explicit alert condition is supported"""

    tags = sgqlc.types.Field(sgqlc.types.list_of("TagKeyValuePairOutput"), graphql_name="tags")
    """Tags for the alert condition"""

    data_quality_dimension = sgqlc.types.Field(String, graphql_name="dataQualityDimension")
    """Data quality dimension for the alert condition"""

    alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null("FreshnessAlertConditionOutput"), graphql_name="alertCondition"
    )
    """Alert condition configuration"""

    detector_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(FreshnessDetectorThresholdOutput), graphql_name="detectorThreshold"
    )
    """Detector freshness threshold"""


class GenerateCollectorTemplate(sgqlc.types.Type):
    """Generate a data collector template (uploaded to S3)"""

    __schema__ = schema
    __field_names__ = ("dc",)
    dc = sgqlc.types.Field(DataCollector, graphql_name="dc")
    """The data collector that was created or updated"""


class GenerateDcUpgradeTemplate(sgqlc.types.Type):
    """Generates a template for DC upgrade and a URL to execute the
    template in the cloud provider.
    """

    __schema__ = schema
    __field_names__ = (
        "upgrade_launch_url",
        "template_url",
        "code_version",
        "template_version",
        "template_variant",
        "is_mc_hosted",
        "is_up_to_date",
    )
    upgrade_launch_url = sgqlc.types.Field(String, graphql_name="upgradeLaunchUrl")
    """A link that launches the upgrade flow (for instance in AWS
    CloudFormation) that customers can complete to upgrade a data
    collector stack.
    """

    template_url = sgqlc.types.Field(String, graphql_name="templateUrl")
    """A link to the deployment template URL (for instance an AWS S3
    URL). This can be used to diff against an existing deployment
    template and review upgrades.
    """

    code_version = sgqlc.types.Field(String, graphql_name="codeVersion")
    """The code version of the upgrade."""

    template_version = sgqlc.types.Field(String, graphql_name="templateVersion")
    """The template version of the upgrade."""

    template_variant = sgqlc.types.Field(String, graphql_name="templateVariant")
    """The template variant of the upgrade."""

    is_mc_hosted = sgqlc.types.Field(Boolean, graphql_name="isMcHosted")
    """Indicates whether the data collector is hosted by Monte Carlo."""

    is_up_to_date = sgqlc.types.Field(Boolean, graphql_name="isUpToDate")
    """Indicates whether the data collector is already running on the
    latest code and infrastructure.
    """


class GenerateReport(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("report_job_id",)
    report_job_id = sgqlc.types.Field(UUID, graphql_name="reportJobId")


class GenerateWebhookUrl(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("webhook_url", "webhook_id", "service")
    webhook_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="webhookUrl")
    """Generate a webhook URL"""

    webhook_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="webhookId")
    """The ID of the webhook"""

    service = sgqlc.types.Field(sgqlc.types.non_null(WebhookServiceTypes), graphql_name="service")
    """The external service"""


class GetAccountAuditLogsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("records", "page_info")
    records = sgqlc.types.Field(sgqlc.types.list_of(AccountAuditLog), graphql_name="records")
    """List of audit log records"""

    page_info = sgqlc.types.Field("PageInfo", graphql_name="pageInfo")
    """Pagination info"""


class GetAlationTableFlags(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("flag_type", "flag_reason")
    flag_type = sgqlc.types.Field(sgqlc.types.non_null(TableFlagType), graphql_name="flagType")
    """The type of the flag. Either WARNING or DEPRECATION"""

    flag_reason = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="flagReason")
    """A reason or a description of the flag"""


class GetTableauAssetWarningByIdResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("message",)
    message = sgqlc.types.Field(String, graphql_name="message")
    """The message body of the warning."""


class GithubAppInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("install_link", "installations")
    install_link = sgqlc.types.Field(String, graphql_name="installLink")
    """Link to click in order to install new Github integration"""

    installations = sgqlc.types.Field(
        sgqlc.types.list_of("GithubAppInstallation"), graphql_name="installations"
    )
    """Metadata about Github App installation"""


class GithubAppInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "show_impact_analysis",
        "host",
        "settings_link",
        "gh_org",
        "display_name",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Internal Github installation uuid"""

    show_impact_analysis = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="showImpactAnalysis"
    )
    """Controls whether or not to show impacted models and reports as a
    PR comment
    """

    host = sgqlc.types.Field(String, graphql_name="host")

    settings_link = sgqlc.types.Field(String, graphql_name="settingsLink")
    """Link to click in order to configure Github App installation"""

    gh_org = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ghOrg")
    """GitHub organization name"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")


class GithubPullRequestConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("GithubPullRequestEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class GithubPullRequestEdge(sgqlc.types.Type):
    """A Relay edge containing a `GithubPullRequest` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("GithubPullRequest", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class GithubPullRequestFile(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("path", "change_type", "additions", "deletions")
    path = sgqlc.types.Field(String, graphql_name="path")
    """File path from the root of the repository"""

    change_type = sgqlc.types.Field(String, graphql_name="changeType")
    """File change type: added, modified, removed"""

    additions = sgqlc.types.Field(Int, graphql_name="additions")
    """Number of lines added"""

    deletions = sgqlc.types.Field(Int, graphql_name="deletions")
    """Number of lines deleted"""


class GithubPullRequestImpact(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon",)
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of a table impacted by the pull request"""


class GithubPullRequestInsight(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("pull_request",)
    pull_request = sgqlc.types.Field(
        sgqlc.types.non_null("GithubPullRequest"), graphql_name="pullRequest"
    )
    """Reference to the pull request identified as root cause"""


class GithubPullRequestsList(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("pull_requests",)
    pull_requests = sgqlc.types.Field(
        sgqlc.types.list_of("GithubPullRequest"), graphql_name="pullRequests"
    )
    """List of pull requests"""


class GithubUser(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("login", "avatar_url", "url")
    login = sgqlc.types.Field(String, graphql_name="login")
    """User login"""

    avatar_url = sgqlc.types.Field(String, graphql_name="avatarUrl")
    """User Avatar URL"""

    url = sgqlc.types.Field(String, graphql_name="url")
    """User webpage url"""


class GitlabAppInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("install_link", "installations")
    install_link = sgqlc.types.Field(String, graphql_name="installLink")
    """Link to click in order to install new Gitlab integration"""

    installations = sgqlc.types.Field(
        sgqlc.types.list_of("GitlabAppInstallation"), graphql_name="installations"
    )
    """Metadata about Gitlab App installation"""


class GitlabAppInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "show_impact_analysis", "host", "project_selection", "display_name")
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Internal Github installation uuid"""

    show_impact_analysis = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="showImpactAnalysis"
    )
    """Controls whether or not to show impacted models and reports as a
    PR comment
    """

    host = sgqlc.types.Field(String, graphql_name="host")

    project_selection = sgqlc.types.Field(
        sgqlc.types.list_of("GitlabProjectSelection"), graphql_name="projectSelection"
    )
    """Projects selected for the Gitlab installation"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")


class GitlabEntityRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name", "path")
    id = sgqlc.types.Field(Int, graphql_name="id")

    name = sgqlc.types.Field(String, graphql_name="name")

    path = sgqlc.types.Field(String, graphql_name="path")


class GitlabNamespace(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("namespace", "namespace_id", "select_all", "projects", "webhook_err")
    namespace = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="namespace")
    """Name of the GitLab group"""

    namespace_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="namespaceId")
    """ID of the GitLab group"""

    select_all = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="selectAll")
    """True if all the projects in the namespace are selected"""

    projects = sgqlc.types.Field(sgqlc.types.list_of("GitlabProject"), graphql_name="projects")
    """List of projects in the namespace"""

    webhook_err = sgqlc.types.Field(String, graphql_name="webhookErr")
    """Error message if webhook creation failed"""


class GitlabProject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name", "selected")
    id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="id")
    """ID of the project"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the project"""

    selected = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="selected")
    """True if the project is selected"""


class GitlabProjectSelection(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("namespace_id", "parents", "projects", "webhook_err", "select_all")
    namespace_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="namespaceId")
    """ID of the Gitlab group or subgroup"""

    parents = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="parents")

    projects = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="projects")

    webhook_err = sgqlc.types.Field(String, graphql_name="webhookErr")
    """Error message in case of webhook creation failure"""

    select_all = sgqlc.types.Field(Boolean, graphql_name="selectAll")


class GitlabTraversalResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("groups", "projects")
    groups = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(GitlabEntityRef)), graphql_name="groups"
    )

    projects = sgqlc.types.Field(sgqlc.types.list_of(GitlabEntityRef), graphql_name="projects")


class GraphEdge(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("source", "destination", "source_id", "destination_id", "hidden")
    source = sgqlc.types.Field(String, graphql_name="source")

    destination = sgqlc.types.Field(String, graphql_name="destination")

    source_id = sgqlc.types.Field(Int, graphql_name="sourceId")

    destination_id = sgqlc.types.Field(Int, graphql_name="destinationId")

    hidden = sgqlc.types.Field(Boolean, graphql_name="hidden")


class HighlightSnippets(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "snippets")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field name"""

    snippets = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="snippets")
    """Highlighted snippet"""


class HolidayCode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("code",)
    code = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="code")
    """Country or financial market code"""


class HolidayName(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "next_date", "occurrence")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Holiday name"""

    next_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="nextDate")
    """Date"""

    occurrence = sgqlc.types.Field(String, graphql_name="occurrence")
    """Textual description of when the holiday occurs"""


class HostingDomainDetails(sgqlc.types.Type):
    """Hosting domain information"""

    __schema__ = schema
    __field_names__ = ("ui", "api", "integrations")
    ui = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ui")
    """Frontend URL"""

    api = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="api")
    """GraphQL API URL"""

    integrations = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="integrations")
    """Integrations Gateway URL"""


class HostingInformation(sgqlc.types.Type):
    """Hosting information"""

    __schema__ = schema
    __field_names__ = (
        "domain_details",
        "login_details",
        "infrastructure_details",
        "network_details",
        "collection_details",
        "available_env_configurations",
    )
    domain_details = sgqlc.types.Field(
        sgqlc.types.non_null(HostingDomainDetails), graphql_name="domainDetails"
    )
    """Hosting domain information"""

    login_details = sgqlc.types.Field(
        sgqlc.types.non_null("LoginDetails"), graphql_name="loginDetails"
    )
    """Login information"""

    infrastructure_details = sgqlc.types.Field(
        sgqlc.types.non_null("InfrastructureDetails"), graphql_name="infrastructureDetails"
    )
    """Infrastructure information"""

    network_details = sgqlc.types.Field(
        sgqlc.types.non_null("NetworkDetails"), graphql_name="networkDetails"
    )
    """Network information"""

    collection_details = sgqlc.types.Field(CollectionDetails, graphql_name="collectionDetails")
    """Collection platform information"""

    available_env_configurations = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(AwsEnvConfiguration)),
        graphql_name="availableEnvConfigurations",
    )
    """List of enabled configurations (primary/secondary)"""


class IgnoredRoutingRuleInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("rule_uuid", "audience_label", "rule_summary")
    rule_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ruleUuid")

    audience_label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="audienceLabel")

    rule_summary = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ruleSummary")


class IncidentCategoryCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("incident_category", "category_count")
    incident_category = sgqlc.types.Field(IncidentCategory, graphql_name="incidentCategory")

    category_count = sgqlc.types.Field(Int, graphql_name="categoryCount")
    """Number of monitors in category"""


class IncidentConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("IncidentEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Both startTime and endTime must be supplied to get totalCount"""


class IncidentDailyCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("day", "incident_count")
    day = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="day")
    """The date for the incident count"""

    incident_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="incidentCount")
    """The incident count"""


class IncidentDashboardData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "total_incident_count",
        "no_status_count",
        "investigating_count",
        "fixed_count",
        "expected_and_no_action_count",
    )
    total_incident_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="totalIncidentCount"
    )
    """The total count of incidents over the specified weeks"""

    no_status_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="noStatusCount")
    """The total count of incidents with no status over the specified
    weeks
    """

    investigating_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="investigatingCount"
    )
    """The total count of incidents with status of investigating over the
    specified weeks
    """

    fixed_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="fixedCount")
    """The total count of incidents with fixed status over the specified
    weeks
    """

    expected_and_no_action_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="expectedAndNoActionCount"
    )
    """The total count of incidents with status expected or no action
    over the specified weeks
    """


class IncidentEdge(sgqlc.types.Type):
    """A Relay edge containing a `Incident` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("Incident", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class IncidentRcaData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("primary_rca", "event_rcas", "incident_rcas")
    primary_rca = sgqlc.types.Field("PrimaryRcaData", graphql_name="primaryRca")

    event_rcas = sgqlc.types.Field(sgqlc.types.list_of(EventRcaData), graphql_name="eventRcas")

    incident_rcas = sgqlc.types.Field(
        sgqlc.types.list_of("IncidentScopedRcaData"), graphql_name="incidentRcas"
    )


class IncidentSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("incident_id", "types", "states", "tables", "key_assets", "has_rca")
    incident_id = sgqlc.types.Field(UUID, graphql_name="incidentId")

    types = sgqlc.types.Field(EventTypeSummary, graphql_name="types")

    states = sgqlc.types.Field(EventStateSummary, graphql_name="states")

    tables = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tables")

    key_assets = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="keyAssets")
    """Key assets(tables) in incident"""

    has_rca = sgqlc.types.Field(Boolean, graphql_name="hasRca")
    """Deprecated: Whether an rca insight exists for this incident"""


class IncidentTableMcons(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tables",)
    tables = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tables")
    """The list of table mcons directly impacted by incident"""


class IncidentTimePeriodAggregateData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("start_date", "end_date", "values")
    start_date = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="startDate")
    """The start date for the aggregated data"""

    end_date = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="endDate")
    """The end date for the aggregated data"""

    values = sgqlc.types.Field(sgqlc.types.list_of("LabelCount"), graphql_name="values")
    """The aggregate label and count for the time time period"""


class IncidentTopology(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("root_events",)
    root_events = sgqlc.types.Field(sgqlc.types.list_of(EventTopology), graphql_name="rootEvents")
    """List of root events in the incident"""


class IncidentTypeSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "anomalies",
        "schema_changes",
        "json_schema_changes",
        "deleted_tables",
        "metric_anomalies",
        "agent_anomalies",
        "metric_comparison_anomalies",
        "custom_rule_anomalies",
        "performance_anomalies",
        "dbt_errors",
        "etl_errors",
        "pseudo_integration_test",
        "rule_run_execution_error",
        "merged",
    )
    anomalies = sgqlc.types.Field(Int, graphql_name="anomalies")

    schema_changes = sgqlc.types.Field(Int, graphql_name="schemaChanges")

    json_schema_changes = sgqlc.types.Field(Int, graphql_name="jsonSchemaChanges")

    deleted_tables = sgqlc.types.Field(Int, graphql_name="deletedTables")

    metric_anomalies = sgqlc.types.Field(Int, graphql_name="metricAnomalies")

    agent_anomalies = sgqlc.types.Field(Int, graphql_name="agentAnomalies")

    metric_comparison_anomalies = sgqlc.types.Field(Int, graphql_name="metricComparisonAnomalies")

    custom_rule_anomalies = sgqlc.types.Field(Int, graphql_name="customRuleAnomalies")

    performance_anomalies = sgqlc.types.Field(Int, graphql_name="performanceAnomalies")

    dbt_errors = sgqlc.types.Field(Int, graphql_name="dbtErrors")

    etl_errors = sgqlc.types.Field(Int, graphql_name="etlErrors")

    pseudo_integration_test = sgqlc.types.Field(Int, graphql_name="pseudoIntegrationTest")

    rule_run_execution_error = sgqlc.types.Field(Int, graphql_name="ruleRunExecutionError")

    merged = sgqlc.types.Field(Int, graphql_name="merged")


class IncidentWeeklyDataDashboard(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("weekly_data",)
    weekly_data = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentTimePeriodAggregateData), graphql_name="weeklyData"
    )
    """The weekly incident data"""


class IncidentsCountByDate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("date", "count")
    date = sgqlc.types.Field(Date, graphql_name="date")
    """Date of the count"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Count of incidents on the date"""


class IncidentsCountByDateConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("IncidentsCountByDateEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class IncidentsCountByDateEdge(sgqlc.types.Type):
    """A Relay edge containing a `IncidentsCountByDate` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(IncidentsCountByDate, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class IncidentsFilter(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "field_name",
        "display_name",
        "incidents_parameter_name",
        "incidents_parameter_accepts_multiple_values",
        "facetable",
        "facet_searchable",
    )
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    incidents_parameter_name = sgqlc.types.Field(String, graphql_name="incidentsParameterName")
    """Associated getIncidents parameter used to filter incidents"""

    incidents_parameter_accepts_multiple_values = sgqlc.types.Field(
        Boolean, graphql_name="incidentsParameterAcceptsMultipleValues"
    )
    """Whether the associated getIncidents parameter accepts multiple
    values as input
    """

    facetable = sgqlc.types.Field(Boolean, graphql_name="facetable")
    """Whether the filter shows up as a facet on the incidents UI page"""

    facet_searchable = sgqlc.types.Field(Boolean, graphql_name="facetSearchable")
    """Whether the filter values can be searched by their display name"""


class IncidentsFilterData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "values", "page_info")
    field_name = sgqlc.types.Field(IncidentsFilterFields, graphql_name="fieldName")

    values = sgqlc.types.Field(
        sgqlc.types.list_of("IncidentsFilterDataValue"), graphql_name="values"
    )
    """List of possible values to filter incidents"""

    page_info = sgqlc.types.Field("NextPageInfo", graphql_name="pageInfo")
    """Data for paginating values"""


class IncidentsFilterDataValue(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value", "display_name", "count", "child_values", "incidents_parameter_name")
    value = sgqlc.types.Field(GenericScalar, graphql_name="value")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    count = sgqlc.types.Field(Int, graphql_name="count")

    child_values = sgqlc.types.Field(
        sgqlc.types.list_of("IncidentsFilterDataValue"), graphql_name="childValues"
    )

    incidents_parameter_name = sgqlc.types.Field(String, graphql_name="incidentsParameterName")
    """If this has a value, it should override the value from
    IncidentsFilter
    """


class IndexedFieldFilterOutputType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "values", "operator")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field name"""

    values = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="values")
    """Values to filter by"""

    operator = sgqlc.types.Field(FieldValueFilterOperator, graphql_name="operator")
    """comparison operator to use when filtering"""


class IndexedFieldSpecType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "field_name",
        "display_name",
        "displayable",
        "aggregatable",
        "facetable",
        "filterable",
        "facet_searchable",
        "dashboard_types",
    )
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    displayable = sgqlc.types.Field(Boolean, graphql_name="displayable")

    aggregatable = sgqlc.types.Field(Boolean, graphql_name="aggregatable")

    facetable = sgqlc.types.Field(Boolean, graphql_name="facetable")

    filterable = sgqlc.types.Field(Boolean, graphql_name="filterable")

    facet_searchable = sgqlc.types.Field(Boolean, graphql_name="facetSearchable")

    dashboard_types = sgqlc.types.Field(
        sgqlc.types.list_of(DashboardType), graphql_name="dashboardTypes"
    )


class InfrastructureDetails(sgqlc.types.Type):
    """Infrastructure information"""

    __schema__ = schema
    __field_names__ = ("cloud_designation", "tenant_id", "hosting_type", "aws", "azure")
    cloud_designation = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="cloudDesignation"
    )
    """Cloud Designation"""

    tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId")
    """Tenant ID"""

    hosting_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="hostingType")
    """Environment Hosting Type"""

    aws = sgqlc.types.Field(sgqlc.types.non_null(AwsInformation), graphql_name="aws")
    """AWS information"""

    azure = sgqlc.types.Field(AzureInformation, graphql_name="azure")
    """Azure information"""


class Insight(sgqlc.types.Type):
    """Available data on a specific element of the system created by DS"""

    __schema__ = schema
    __field_names__ = ("name", "title", "usage", "description", "reports", "available")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name (id) of insight"""

    title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title")
    """Insight display name"""

    usage = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="usage")
    """Explains what the insight data can be used for"""

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")
    """Information the reports for the insight will provide"""

    reports = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("Report")), graphql_name="reports"
    )
    """Reports available for the insight"""

    available = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="available")
    """True if this insight is currently available"""


class IntegrationKey(sgqlc.types.Type):
    """Integration key id and secret. Only available once."""

    __schema__ = schema
    __field_names__ = ("id", "secret")
    id = sgqlc.types.Field(String, graphql_name="id")
    """Key id"""

    secret = sgqlc.types.Field(String, graphql_name="secret")
    """Key secret"""


class IntegrationKeyMetadata(sgqlc.types.Type):
    """Metadata for an integration key (will not include the associated
    secret)
    """

    __schema__ = schema
    __field_names__ = ("id", "description", "scope", "warehouses", "created_time", "created_by")
    id = sgqlc.types.Field(String, graphql_name="id")
    """Key id"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Key description"""

    scope = sgqlc.types.Field(String, graphql_name="scope")
    """Key scope (integration it can be used for)"""

    warehouses = sgqlc.types.Field(sgqlc.types.list_of("Warehouse"), graphql_name="warehouses")
    """Warehouses associated with key"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """Time key was created"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the key"""


class IntegrationUpdateResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "type", "name")
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")


class InternalNotifications(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("type", "friendly_message", "details", "is_urgent", "expiration_date")
    type = sgqlc.types.Field(String, graphql_name="type")
    """Type of notification."""

    friendly_message = sgqlc.types.Field(String, graphql_name="friendlyMessage")
    """Human readable message."""

    details = sgqlc.types.Field(JSONString, graphql_name="details")
    """Raw information about the message (e.g. specifics)."""

    is_urgent = sgqlc.types.Field(Boolean, graphql_name="isUrgent")
    """Whether to display a modal or badge."""

    expiration_date = sgqlc.types.Field(DateTime, graphql_name="expirationDate")
    """Reserved for future use (e.g. hiding old messages)."""


class InvestigationQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query", "has_error")
    query = sgqlc.types.Field(String, graphql_name="query")

    has_error = sgqlc.types.Field(Boolean, graphql_name="hasError")


class InviteUsersPayload(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("users", "client_mutation_id")
    users = sgqlc.types.Field(sgqlc.types.list_of("UserInvite"), graphql_name="users")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class InviteUsersV2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("invites", "existing_users", "already_invited")
    invites = sgqlc.types.Field(sgqlc.types.list_of("UserInvite"), graphql_name="invites")
    """List of users invites sent"""

    existing_users = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="existingUsers")
    """List of email addresses of users who already exist and cannot be
    invited
    """

    already_invited = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="alreadyInvited")
    """List of email addresses already invited to this account or another
    account
    """


class JiraIntegrationOutput(sgqlc.types.Type):
    """A Jira integration"""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "server_url",
        "username",
        "default_ticket_fields",
        "webhook_enabled",
        "webhook_url",
        "webhook_config",
        "is_token_auth",
        "webhook_secret_defined",
        "webhook_secret_mismatch_detected",
        "created_time",
        "updated_time",
        "created_by",
        "last_updated_by",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """A short name to identify the integration"""

    server_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="serverUrl")
    """The domain name for your Jira site"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """The Jira username for basic authentication."""

    default_ticket_fields = sgqlc.types.Field(JSONString, graphql_name="defaultTicketFields")
    """Default values for ticket fields."""

    webhook_enabled = sgqlc.types.Field(Boolean, graphql_name="webhookEnabled")
    """Whether the Jira webhook is enabled"""

    webhook_url = sgqlc.types.Field(String, graphql_name="webhookUrl")
    """The Jira webhook URL. Configure this as the target of your Jira
    Webhook.
    """

    webhook_config = sgqlc.types.Field("JiraWebhookConfigOutput", graphql_name="webhookConfig")
    """Webhook config"""

    is_token_auth = sgqlc.types.Field(Boolean, graphql_name="isTokenAuth")
    """If the integration is Basic or Token Auth"""

    webhook_secret_defined = sgqlc.types.Field(Boolean, graphql_name="webhookSecretDefined")
    """Whether a secret has been configured for validating the signatures
    of webhook payloads sent by JIRA
    """

    webhook_secret_mismatch_detected = sgqlc.types.Field(
        Boolean, graphql_name="webhookSecretMismatchDetected"
    )
    """Indicates whether a mismatch was detected for the JIRA secret in
    the received payloads
    """

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_updated_by = sgqlc.types.Field("User", graphql_name="lastUpdatedBy")
    """Who last updated the integration"""


class JiraIssueTypeFieldAllowedValueOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "display_value", "children")
    id = sgqlc.types.Field(String, graphql_name="id")
    """The option's ID"""

    display_value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayValue")
    """The option's user friendly display value"""

    children = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("JiraIssueTypeFieldAllowedValueOutput")),
        graphql_name="children",
    )
    """For dependant option types, the option's children"""


class JiraIssueTypeFieldOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "key",
        "name",
        "required",
        "has_default_value",
        "has_default_value_in_jira",
        "type",
        "custom_type",
        "items_type",
        "allowed_values",
        "default_value",
        "is_multi",
    )
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """The field key"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The field name"""

    required = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="required")
    """If the field is required to create the issue"""

    has_default_value = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasDefaultValue"
    )
    """If the field has a default value when not set, considering
    integration level default values configured on Monte Carlo
    """

    has_default_value_in_jira = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasDefaultValueInJira"
    )
    """If the field has a default value in Jira when not set"""

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")
    """The field type"""

    custom_type = sgqlc.types.Field(String, graphql_name="customType")
    """For custom fields, the JIRA custom field type"""

    items_type = sgqlc.types.Field(String, graphql_name="itemsType")
    """For array types, the type of the items in the array"""

    allowed_values = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraIssueTypeFieldAllowedValueOutput)),
        graphql_name="allowedValues",
    )
    """The allowed values for option fields"""

    default_value = sgqlc.types.Field(JSONString, graphql_name="defaultValue")
    """JSON-string representing the JIRA defined default value for this
    field
    """

    is_multi = sgqlc.types.Field(Boolean, graphql_name="isMulti")
    """For array type fields, indicates if more than one value is allowed"""


class JiraIssueTypeOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name", "untranslated_name", "fields")
    id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="id")
    """The issue type ID"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The issue type name"""

    untranslated_name = sgqlc.types.Field(String, graphql_name="untranslatedName")
    """The issue type untranslated name"""

    fields = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(JiraIssueTypeFieldOutput))),
        graphql_name="fields",
    )
    """The issue type fields"""


class JiraProjectOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "key", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="id")
    """The project ID"""

    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """The project key"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The project name"""


class JiraStatusMappingOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("incident_feedback", "jira_status")
    incident_feedback = sgqlc.types.Field(String, graphql_name="incidentFeedback")
    """The feedback that will be set on the Monte Carlo incident if the
    Jira ticket is set to any of the provided Jira statuses
    """

    jira_status = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="jiraStatus"
    )
    """The Jira statuses that will map to the Monte Carlo incident
    feedback
    """


class JiraStatusOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """The status ID"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The status name"""


class JiraTeamOutput(sgqlc.types.Type):
    """A JIRA team details"""

    __schema__ = schema
    __field_names__ = ("team_id", "display_name", "description", "team_type")
    team_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="teamId")
    """The team ID"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """The team display name"""

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")
    """The team description"""

    team_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="teamType")
    """The team type"""


class JiraTestCredentialsOutput(sgqlc.types.Type):
    """A Jira test credentials result"""

    __schema__ = schema
    __field_names__ = ("valid_credentials",)
    valid_credentials = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="validCredentials"
    )
    """Returns if the credentials are valid"""


class JiraTicketDetailsOutput(sgqlc.types.Type):
    """Ticket details stored at Jira"""

    __schema__ = schema
    __field_names__ = ("assignee", "status", "found")
    assignee = sgqlc.types.Field("JiraUserOutput", graphql_name="assignee")
    """The user assigned to the ticket"""

    status = sgqlc.types.Field("JiraTicketStatusOutput", graphql_name="status")
    """The ticket status"""

    found = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="found")
    """Whether the ticket was found in JIRA"""


class JiraTicketOutput(sgqlc.types.Type):
    """A Jira ticket"""

    __schema__ = schema
    __field_names__ = (
        "ticket_id",
        "ticket_url",
        "ticket_key",
        "incident_id",
        "alert_id",
        "integration_id",
        "created_by",
        "created_at",
        "details",
    )
    ticket_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="ticketId")
    """The ticket ID in Monte Carlo"""

    ticket_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ticketUrl")
    """The ticket URL"""

    ticket_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ticketKey")
    """The ticket key"""

    incident_id = sgqlc.types.Field(UUID, graphql_name="incidentId")
    """The incident ID"""

    alert_id = sgqlc.types.Field(UUID, graphql_name="alertId")
    """The alert ID"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """The integration ID. Might be null if integration was deleted."""

    created_by = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="createdBy")
    """Email of the user that created the ticket"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")
    """When the ticket was created"""

    details = sgqlc.types.Field(JiraTicketDetailsOutput, graphql_name="details")
    """Ticket details stored at Jira"""


class JiraTicketStatusOutput(sgqlc.types.Type):
    """A JIRA ticket status"""

    __schema__ = schema
    __field_names__ = ("name", "description")
    name = sgqlc.types.Field(String, graphql_name="name")
    """A short descriptive name for the status"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """A more detailed description of the status"""


class JiraUserOutput(sgqlc.types.Type):
    """A JIRA user details"""

    __schema__ = schema
    __field_names__ = ("avatar_url", "display_name", "email_address", "name", "account_id", "key")
    avatar_url = sgqlc.types.Field(String, graphql_name="avatarUrl")
    """The user 24x24 avatar URL"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """The user display name"""

    email_address = sgqlc.types.Field(String, graphql_name="emailAddress")
    """The user email"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """The JIRA DC user name (this uniquely identifies the user)"""

    account_id = sgqlc.types.Field(String, graphql_name="accountId")
    """The JIRA Cloud user accountId (this ID uniquely identifies the
    user)
    """

    key = sgqlc.types.Field(String, graphql_name="key")
    """The JIRA DC user key (this ID uniquely identifies the user)"""


class JiraWebhookConfigOutput(sgqlc.types.Type):
    """Jira webhook config"""

    __schema__ = schema
    __field_names__ = ("status_mappings",)
    status_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraStatusMappingOutput)),
        graphql_name="statusMappings",
    )
    """Status mapping"""


class JobError(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "message",
        "job_execution_uuid",
        "dc_schedule_uuid",
        "timestamp",
        "result_count",
        "job_type",
        "stack_name",
        "data_collector_uuid",
    )
    message = sgqlc.types.Field(String, graphql_name="message")
    """The error message"""

    job_execution_uuid = sgqlc.types.Field(UUID, graphql_name="jobExecutionUuid")
    """The Job Execution ID"""

    dc_schedule_uuid = sgqlc.types.Field(UUID, graphql_name="dcScheduleUuid")
    """The data collector schedule UUID"""

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """The timestamp of the error"""

    result_count = sgqlc.types.Field(Int, graphql_name="resultCount")
    """The number of results returned"""

    job_type = sgqlc.types.Field(String, graphql_name="jobType")
    """The type of job that failed"""

    stack_name = sgqlc.types.Field(String, graphql_name="stackName")
    """The name of the stack for the data collector"""

    data_collector_uuid = sgqlc.types.Field(UUID, graphql_name="dataCollectorUuid")
    """The data collector uuid"""


class JobExecutionException(sgqlc.types.Type):
    """Job execution exception details"""

    __schema__ = schema
    __field_names__ = ("type", "description", "sql_query")
    type = sgqlc.types.Field(String, graphql_name="type")
    """Exception type"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Exception description"""

    sql_query = sgqlc.types.Field(String, graphql_name="sqlQuery")
    """SQL query execution that triggered the exception"""


class JobExecutionHistoryLog(sgqlc.types.Type):
    """Job history log entry"""

    __schema__ = schema
    __field_names__ = (
        "job_execution_uuid",
        "start_time",
        "status",
        "end_time",
        "exceptions",
        "exceptions_detail",
        "runtime_variables",
        "comparison_data_source_type",
        "table_monitor_warning",
        "size_collection_table_mcon",
        "size_collection_enabled",
        "total_invocations_count",
        "total_result_count",
        "total_execution_duration",
        "consolidating_job_uuid",
    )
    job_execution_uuid = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="jobExecutionUuid"
    )
    """UUID of job execution"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """When the job was scheduled"""

    status = sgqlc.types.Field(JobExecutionStatus, graphql_name="status")

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """When the job was completed"""

    exceptions = sgqlc.types.Field(String, graphql_name="exceptions")
    """Exceptions that were captured during this job execution (pre-
    formatted)
    """

    exceptions_detail = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JobExecutionException)),
        graphql_name="exceptionsDetail",
    )
    """Exceptions that were captured during this job execution"""

    runtime_variables = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("VariableValue")), graphql_name="runtimeVariables"
    )
    """Runtime variables used in the job execution"""

    comparison_data_source_type = sgqlc.types.Field(
        ComparisonDataSourceType, graphql_name="comparisonDataSourceType"
    )
    """Comparison Source type in the job execution"""

    table_monitor_warning = sgqlc.types.Field(Boolean, graphql_name="tableMonitorWarning")
    """True if this table monitor execution failure was treated as a
    warning and no failure notification was sent.
    """

    size_collection_table_mcon = sgqlc.types.Field(String, graphql_name="sizeCollectionTableMcon")
    """MCON of the table for size collection executions in table monitors"""

    size_collection_enabled = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="sizeCollectionEnabled"
    )
    """True if size collection is enabled for the asset"""

    total_invocations_count = sgqlc.types.Field(Int, graphql_name="totalInvocationsCount")
    """Total number of invocations for the job execution. May be null if
    execution has not completed.
    """

    total_result_count = sgqlc.types.Field(Int, graphql_name="totalResultCount")
    """Total number of objects returned by the job execution. May be null
    if execution has not completed.
    """

    total_execution_duration = sgqlc.types.Field(Float, graphql_name="totalExecutionDuration")
    """Total execution duration in seconds. May be null if execution has
    not completed.
    """

    consolidating_job_uuid = sgqlc.types.Field(String, graphql_name="consolidatingJobUuid")
    """UUID of the consolidating job execution"""


class JobExecutionHistoryLogConnection(sgqlc.types.relay.Connection):
    """Job history log entries"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("JobExecutionHistoryLogEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class JobExecutionHistoryLogEdge(sgqlc.types.Type):
    """A Relay edge containing a `JobExecutionHistoryLog` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(JobExecutionHistoryLog, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class JobInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_job_info",)
    dbt_job_info = sgqlc.types.Field(DbtJobInfo, graphql_name="dbtJobInfo")


class JobPerformanceData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("job_summaries",)
    job_summaries = sgqlc.types.Field(
        sgqlc.types.non_null("JobPerformanceSummaryConnection"),
        graphql_name="jobSummaries",
        args=sgqlc.types.ArgDict(
            (
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Paged list of summary-level information about job performance, for
    jobs that executed in the specified period

    Arguments:

    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class JobPerformanceSummaryConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("JobPerformanceSummaryEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of jobs matching filter (total count)"""


class JobPerformanceSummaryEdge(sgqlc.types.Type):
    """A Relay edge containing a `JobPerformanceSummary` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("JobPerformanceSummary", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class JobRoutingRuleSpec(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "original_rule_uuid",
        "audience",
        "job_anomaly_types",
        "job_sub_types",
        "job_asset_rules",
        "description",
    )
    original_rule_uuid = sgqlc.types.Field(
        sgqlc.types.non_null(UUID), graphql_name="originalRuleUuid"
    )

    audience = sgqlc.types.Field(Audience, graphql_name="audience")

    job_anomaly_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="jobAnomalyTypes",
    )

    job_sub_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="jobSubTypes",
    )

    job_asset_rules = sgqlc.types.Field(GenericScalar, graphql_name="jobAssetRules")

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")


class JobsPerformanceFacetOption(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("display_name", "value", "match_count")
    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Display text to use, if different from value, such as when value
    is a UUID but we want human readable option
    """

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """Unique value (within the facet) for the option"""

    match_count = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="matchCount")
    """Number of jobs associated with this value"""


class JobsPerformanceFacetResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("facet", "display_name", "options")
    facet = sgqlc.types.Field(sgqlc.types.non_null(JobPerformanceFacet), graphql_name="facet")
    """Field name"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Facet display name"""

    options = sgqlc.types.Field(
        sgqlc.types.list_of(JobsPerformanceFacetOption), graphql_name="options"
    )
    """Facet options"""


class LLMModel(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "description",
        "warehouse_type",
        "category",
        "context_window",
        "regions",
        "default",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")

    warehouse_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="warehouseType")

    category = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="category")

    context_window = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="contextWindow")

    regions = sgqlc.types.Field(GenericScalar, graphql_name="regions")

    default = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="default")


class LabelCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("label", "count")
    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")
    """The label value"""

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")
    """The count for the label"""


class LastSizeChange(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("timestamp", "size", "size_delta")
    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """Timestamp when the last size change occurred"""

    size = sgqlc.types.Field(Float, graphql_name="size")
    """Table size after the last size change occurred"""

    size_delta = sgqlc.types.Field(Float, graphql_name="sizeDelta")
    """Size delta to the previous table size change"""


class LineageAirflowJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "dag_id",
        "task_id",
        "display_name",
        "resource_name",
        "mcon",
        "status",
        "last_run_finished_at",
    )
    dag_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dagId")
    """Airflow DAG Id"""

    task_id = sgqlc.types.Field(String, graphql_name="taskId")
    """Airflow Task Id"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Airflow DAG Name"""

    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """Airflow Environment Name"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Airflow DAG MCON"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status of most recent job execution"""

    last_run_finished_at = sgqlc.types.Field(DateTime, graphql_name="lastRunFinishedAt")
    """Timestamp of the most recent job execution's completion"""


class LineageAzureDataFactoryJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "job_id",
        "task_id",
        "display_name",
        "resource_name",
        "mcon",
        "status",
        "last_run_finished_at",
    )
    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Azure Data Factory Pipeline Id"""

    task_id = sgqlc.types.Field(String, graphql_name="taskId")
    """Azure Data Factory Activity Id"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Azure Data Factory Pipeline Name"""

    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """Azure Data Factory Environment Name"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Azure Data Factory Pipeline MCON"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status of most recent pipeline execution"""

    last_run_finished_at = sgqlc.types.Field(DateTime, graphql_name="lastRunFinishedAt")
    """Timestamp of the most recent pipeline execution's completion"""


class LineageBaseJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("display_name", "mcon", "status", "last_run_finished_at")
    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Job name"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Job MCON"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status of most recent job execution"""

    last_run_finished_at = sgqlc.types.Field(DateTime, graphql_name="lastRunFinishedAt")
    """Timestamp of the most recent job execution's completion"""


class LineageDatabricksJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "job_id",
        "task_id",
        "display_name",
        "resource_name",
        "mcon",
        "status",
        "last_run_finished_at",
    )
    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Databricks Job Id"""

    task_id = sgqlc.types.Field(String, graphql_name="taskId")
    """Databricks task Id"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Databricks Job Name"""

    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """Databricks Environment Name"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Databricks Job MCON"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status of most recent job execution"""

    last_run_finished_at = sgqlc.types.Field(DateTime, graphql_name="lastRunFinishedAt")
    """Timestamp of the most recent job execution's completion"""


class LineageDbtJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("job_uuid", "display_name", "resource_id", "mcon")
    job_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobUuid")
    """DBT job uuid"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """DBT job name"""

    resource_id = sgqlc.types.Field(String, graphql_name="resourceId")
    """UUID of the Monte Carlo resource/integration which isassociated to
    the DBT job
    """

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """DBT job MCON"""


class LineageEdgeJob(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("job_type", "job_attributes")
    job_type = sgqlc.types.Field(sgqlc.types.non_null(LineageNodeJobType), graphql_name="jobType")
    """Job type"""

    job_attributes = sgqlc.types.Field(
        sgqlc.types.non_null("LineageJobAttributes"), graphql_name="jobAttributes"
    )


class LineageFivetranJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "connector_id",
        "service",
        "connector_schema",
        "resource_id",
        "resource_name",
        "sync_state",
        "setup_state",
        "update_state",
        "display_name",
        "mcon",
        "status",
        "last_run_finished_at",
    )
    connector_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="connectorId")
    """Fivetran connector ID"""

    service = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="service")
    """Fivetran connector service (e.g., facebook_ads)"""

    connector_schema = sgqlc.types.Field(String, graphql_name="connectorSchema")
    """Fivetran connector schema"""

    resource_id = sgqlc.types.Field(String, graphql_name="resourceId")
    """UUID of the Monte Carlo ETL container resource"""

    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """Name of the Fivetran ETL container"""

    sync_state = sgqlc.types.Field(String, graphql_name="syncState")
    """Current sync state of the connector"""

    setup_state = sgqlc.types.Field(String, graphql_name="setupState")
    """Current setup state of the connector"""

    update_state = sgqlc.types.Field(String, graphql_name="updateState")
    """Current update state of the connector"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Fivetran connector display name"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Fivetran connector MCON"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status of most recent connector sync"""

    last_run_finished_at = sgqlc.types.Field(DateTime, graphql_name="lastRunFinishedAt")
    """Timestamp of the most recent successful sync"""


class LineageGraph(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("base_node", "base_nodes", "connected_nodes", "flattened_edges")
    base_node = sgqlc.types.Field("LineageGraphNode", graphql_name="baseNode")
    """This is the base node for which lineage is fetched. If there are
    multiples nodes requested this is the first one.
    """

    base_nodes = sgqlc.types.Field(
        sgqlc.types.list_of("LineageGraphNode"), graphql_name="baseNodes"
    )
    """These are the base nodes for which lineages are fetched"""

    connected_nodes = sgqlc.types.Field(
        sgqlc.types.list_of("LineageGraphNode"), graphql_name="connectedNodes"
    )
    """List of nodes connected to the base node. This could be nodes that
    are multiple hops away from the base node in the graph in cases
    where nodes at multiple hops were queried.
    """

    flattened_edges = sgqlc.types.Field(
        sgqlc.types.list_of(FlattenedLineageGraphEdges), graphql_name="flattenedEdges"
    )
    """Each entry is an mcon and a list of mcons it is directly connected
    to
    """


class LineageGraphEdge(sgqlc.types.Type):
    """A lineage graph edge"""

    __schema__ = schema
    __field_names__ = ("source", "destination", "job_ts", "expire_at", "is_custom")
    source = sgqlc.types.Field("LineageGraphNode", graphql_name="source")
    """The source node"""

    destination = sgqlc.types.Field("LineageGraphNode", graphql_name="destination")
    """The destination node"""

    job_ts = sgqlc.types.Field(DateTime, graphql_name="jobTs")
    """The timestamp of the job run or API call that created this edge"""

    expire_at = sgqlc.types.Field(DateTime, graphql_name="expireAt")
    """The timestamp when this edge will expire"""

    is_custom = sgqlc.types.Field(Boolean, graphql_name="isCustom")
    """Indicates whether this is a custom lineage edge (created by a
    user)
    """


class LineageGraphEdgeJobs(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("source_mcon", "destination_mcon", "jobs")
    source_mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sourceMcon")

    destination_mcon = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="destinationMcon"
    )

    jobs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(LineageEdgeJob)), graphql_name="jobs"
    )
    """Jobs associated to this edge"""


class LineageGraphEdgeNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "jobs", "hidden")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Target MCON of this edge"""

    jobs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(LineageEdgeJob)), graphql_name="jobs"
    )
    """Jobs associated to this edge"""

    hidden = sgqlc.types.Field(Int, graphql_name="hidden")
    """The number of hidden nodes for virtual/collapsed edges"""


class LineageGraphNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "display_name",
        "has_downstream_nodes",
        "has_upstream_nodes",
        "object_type",
        "is_custom",
        "job_ts",
        "expire_at",
        "jobs",
        "is_monitored",
        "is_excluded",
        "last_activity",
        "model_execution_status",
        "element_id",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Monte Carlo full identifier for an entity"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Friendly name for entity"""

    has_downstream_nodes = sgqlc.types.Field(Boolean, graphql_name="hasDownstreamNodes")
    """Indicates whether this node has downstream nodes"""

    has_upstream_nodes = sgqlc.types.Field(Boolean, graphql_name="hasUpstreamNodes")
    """Indicates whether this node has upstream nodes"""

    object_type = sgqlc.types.Field(String, graphql_name="objectType")
    """Type of the object that this lineage node denotes"""

    is_custom = sgqlc.types.Field(Boolean, graphql_name="isCustom")
    """Indicates whether this is a custom lineage node (created by a
    user)
    """

    job_ts = sgqlc.types.Field(DateTime, graphql_name="jobTs")
    """The timestamp of the job run or API call that created this node"""

    expire_at = sgqlc.types.Field(DateTime, graphql_name="expireAt")
    """The timestamp when this node will expire"""

    jobs = sgqlc.types.Field(sgqlc.types.list_of("LineageNodeJob"), graphql_name="jobs")
    """List of jobs"""

    is_monitored = sgqlc.types.Field(Boolean, graphql_name="isMonitored")
    """Indicates whether this is table asset is opt-in for monitoring"""

    is_excluded = sgqlc.types.Field(Boolean, graphql_name="isExcluded")
    """Indicates whether this is table asset is excluded from ingestion"""

    last_activity = sgqlc.types.Field(DateTime, graphql_name="lastActivity")
    """Last read/write on table"""

    model_execution_status = sgqlc.types.Field(
        "LineageGraphNodeModelExecutionStatus", graphql_name="modelExecutionStatus"
    )
    """The most recent model execution status information which affected
    this table (e.g. DBT model)
    """

    element_id = sgqlc.types.Field(Int, graphql_name="elementId")
    """Internal lineage node id. Only unique for current run."""


class LineageGraphNodeJobs(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "jobs", "model_execution_status")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Table MCON"""

    jobs = sgqlc.types.Field(sgqlc.types.list_of("LineageNodeJob"), graphql_name="jobs")
    """List of jobs"""

    model_execution_status = sgqlc.types.Field(
        "LineageGraphNodeModelExecutionStatus", graphql_name="modelExecutionStatus"
    )
    """The most recent model execution status information which affected
    this table (e.g. DBT model)
    """


class LineageGraphNodeModelExecutionStatus(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "mcon",
        "account_id",
        "model_type",
        "status",
        "run_at",
        "completed_at",
        "execution_time",
        "model_id",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """The MCON of the table associated to this model execution"""

    account_id = sgqlc.types.Field(UUID, graphql_name="accountId")
    """The account uuid associated to this record"""

    model_type = sgqlc.types.Field(
        sgqlc.types.non_null(ModelExecutionTypes), graphql_name="modelType"
    )
    """The type of the model (e.g. DBT)"""

    status = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="status")
    """The status of the most recent execution of a model which affected
    the associated node
    """

    run_at = sgqlc.types.Field(DateTime, graphql_name="runAt")
    """The timestamp of the most recent execution of a model which
    affected the associated node
    """

    completed_at = sgqlc.types.Field(DateTime, graphql_name="completedAt")
    """The timestamp of the completion of the most recent execution of a
    model which affected the associated node
    """

    execution_time = sgqlc.types.Field(Float, graphql_name="executionTime")
    """The model execution duration"""

    model_id = sgqlc.types.Field(String, graphql_name="modelId")
    """The ID of the associated model execution record (e.g.
    DbtRunStepModel)
    """


class LineageGraphNodesEdgesJobs(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes", "edges")
    nodes = sgqlc.types.Field(sgqlc.types.list_of(LineageGraphNodeJobs), graphql_name="nodes")
    """Lineage nodes with jobs"""

    edges = sgqlc.types.Field(sgqlc.types.list_of(LineageGraphEdgeJobs), graphql_name="edges")
    """Lineage edges with jobs"""


class LineageInformaticaJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "resource_name",
        "mcon",
        "informatica_activity_type",
        "task_flow_id",
        "task_flow_name",
        "task_id",
        "task_name",
        "status",
        "last_run_finished_at",
    )
    resource_name = sgqlc.types.Field(String, graphql_name="resourceName")
    """Informatica integration name"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Informatica job MCON"""

    informatica_activity_type = sgqlc.types.Field(
        InformaticaActivityType, graphql_name="informaticaActivityType"
    )
    """Informatica activity type"""

    task_flow_id = sgqlc.types.Field(String, graphql_name="taskFlowId")
    """Informatica task flow id"""

    task_flow_name = sgqlc.types.Field(String, graphql_name="taskFlowName")
    """Informatica task flow name"""

    task_id = sgqlc.types.Field(String, graphql_name="taskId")
    """Informatica task id"""

    task_name = sgqlc.types.Field(String, graphql_name="taskName")
    """Informatica task name"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status of most recent job execution"""

    last_run_finished_at = sgqlc.types.Field(DateTime, graphql_name="lastRunFinishedAt")
    """Timestamp of the most recent job execution's completion"""


class LineageKafkaConnectorJobAttributes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "job_id",
        "display_name",
        "external_origin_id",
        "external_cluster_id",
        "mcon",
    )
    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Kafka Connector ID"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """kafka Connector display name"""

    external_origin_id = sgqlc.types.Field(String, graphql_name="externalOriginId")
    """External unique identifier of the job"""

    external_cluster_id = sgqlc.types.Field(String, graphql_name="externalClusterId")
    """Cluster the connector runs in"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Kafka Connector MCON"""


class LineageMconNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "importance_score")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MC resource identifier"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """Entity importance score"""


class LineageNodeBlockPattern(sgqlc.types.Type):
    """A pattern defining nodes to be blocked from lineage"""

    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "account_id",
        "resource_id",
        "dataset_regexp",
        "project_regexp",
        "table_regexp",
        "created_time",
        "last_update_user",
        "last_update_time",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Pattern UUID"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Resource containing the node"""

    dataset_regexp = sgqlc.types.Field(String, graphql_name="datasetRegexp")
    """Block nodes with dataset id matching this regexp"""

    project_regexp = sgqlc.types.Field(String, graphql_name="projectRegexp")
    """Block nodes with project id matching this regexp"""

    table_regexp = sgqlc.types.Field(String, graphql_name="tableRegexp")
    """Block nodes with table id matching this regexp"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the regexp was first created"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the regexp"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the regexp was last updated"""


class LineageNodeCollapsingRule(sgqlc.types.Type):
    """A pattern matching lineage nodes that should be collapsed"""

    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "account_id",
        "pattern",
        "case_insensitive",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Collapsing pattern UUID"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    pattern = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pattern")
    """Pattern to match collapsible nodes global id"""

    case_insensitive = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="caseInsensitive"
    )
    """Case sensitivity of the pattern matching"""


class LineageNodeJob(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("job_type", "job_attributes", "direction")
    job_type = sgqlc.types.Field(sgqlc.types.non_null(LineageNodeJobType), graphql_name="jobType")
    """Job type"""

    job_attributes = sgqlc.types.Field(
        sgqlc.types.non_null("LineageJobAttributes"), graphql_name="jobAttributes"
    )

    direction = sgqlc.types.Field(
        sgqlc.types.non_null(LineageNodeJobDirectionType), graphql_name="direction"
    )
    """Directional relationship of the table that the job
    (node) is associated with.             - source (table is source):
    means that the job reads the table (node)                 that
    this job node is associated with.             - dest (table is
    destination): means that the job modifies the table (node)
    that this job node is associated with.
    """


class LineageNodeReplacementRule(sgqlc.types.Type):
    """A replacement pattern modifying lineage node's canonical name"""

    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "account_id",
        "resource_id",
        "pattern",
        "replacement",
        "case_insensitive",
        "last_update_user",
        "last_update_time",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Replacement rule UUID"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Resource containing the node"""

    pattern = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pattern")
    """Modify canonical name by replacing the pattern with replacement"""

    replacement = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="replacement")
    """Modify canonical name by replacing the pattern with replacement"""

    case_insensitive = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="caseInsensitive"
    )
    """Case sensitivity of the pattern matching"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the replacement rule"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the replacement rule was last updated"""


class LineageNodeReplacementRuleResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("test_input_string", "replaced_string")
    test_input_string = sgqlc.types.Field(String, graphql_name="testInputString")
    """The provided test input string"""

    replaced_string = sgqlc.types.Field(String, graphql_name="replacedString")
    """The replaced string, using provided pattern/replacement"""


class LineageNodeTypeStat(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("object_type", "count")
    object_type = sgqlc.types.Field(String, graphql_name="objectType")
    """Type of element object"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Number of elements of object_type"""


class LineageNodeTypeStats(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("node_type_stats",)
    node_type_stats = sgqlc.types.Field(
        sgqlc.types.list_of(LineageNodeTypeStat), graphql_name="nodeTypeStats"
    )
    """Stats for node types"""


class LineageSources(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "source_columns")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Mcon of the source table"""

    source_columns = sgqlc.types.Field(
        sgqlc.types.list_of("SourceColumn"), graphql_name="sourceColumns"
    )
    """Source columns from this source table"""


class LinkAzureDevOpsIntegration(sgqlc.types.Type):
    """Complete OAuth flow for Azure DevOps integration."""

    __schema__ = schema
    __field_names__ = ("success", "azure_devops_integration")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if exchanging code for tokens was successful"""

    azure_devops_integration = sgqlc.types.Field(
        AzureDevOpsIntegrationOutput, graphql_name="azureDevopsIntegration"
    )
    """Created or updated Azure DevOps integration"""


class LinkAzureDevOpsWorkItemForAlert(sgqlc.types.Type):
    """Link an existing Azure DevOps work item to a Monte Carlo alert.
    This mutation creates a link between an existing work item and an
    alert without creating a new work item.
    """

    __schema__ = schema
    __field_names__ = ("azure_devops_work_item",)
    azure_devops_work_item = sgqlc.types.Field(
        AzureDevOpsWorkItemOutput, graphql_name="azureDevopsWorkItem"
    )


class LinkAzureDevopsInstallation(sgqlc.types.Type):
    """Called from the FE when an OAuth callback is received."""

    __schema__ = schema
    __field_names__ = ("success", "installation")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if exchanging code for tokens was successful"""

    installation = sgqlc.types.Field(AzureDevopsInstallation, graphql_name="installation")
    """Updated Azure DevOps installation"""


class LinkDatadogIncidentForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("datadog_incident",)
    datadog_incident = sgqlc.types.Field("DatadogIncident", graphql_name="datadogIncident")
    """The linked Datadog incident"""


class LinkGithubAppInstallation(sgqlc.types.Type):
    """Called from the FE as part of the post-installation callback. The
    "code" parameter is used to validate that the request is an
    authentic Github callback and authenticates the user on the Github
    side.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if linking the installation was successful"""


class LinkGitlabApp(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "installation_id")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if linking the installation was successful"""

    installation_id = sgqlc.types.Field(String, graphql_name="installationId")
    """Internal UUID of the installation"""


class LinkJiraTicketForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("jira_ticket",)
    jira_ticket = sgqlc.types.Field(JiraTicketOutput, graphql_name="jiraTicket")
    """The created Jira ticket"""


class LinkJiraTicketForIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("jira_ticket",)
    jira_ticket = sgqlc.types.Field(JiraTicketOutput, graphql_name="jiraTicket")
    """The created Jira ticket"""


class LinkMsTeamsInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if linking the installation was successful"""


class LinkOpsgenieIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("link_details",)
    link_details = sgqlc.types.Field("OpsgenieLinkOutput", graphql_name="linkDetails")
    """The link details"""


class LinkServiceNowIncidentForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("servicenow_incident",)
    servicenow_incident = sgqlc.types.Field(
        "ServiceNowIncidentOutput", graphql_name="servicenowIncident"
    )
    """The created ServiceNow incident"""


class LinkSlackAppInstallation(sgqlc.types.Type):
    """Handle Slack OAuth callback"""

    __schema__ = schema
    __field_names__ = ("installation_uuid",)
    installation_uuid = sgqlc.types.Field(String, graphql_name="installationUuid")
    """The UUID of the Slack installation"""


class ListDataOperationsDashboardsOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_count", "data_operations_dashboards", "next_page_info")
    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """total count of the operations dashboards."""

    data_operations_dashboards = sgqlc.types.Field(
        sgqlc.types.list_of(DataOperationsDashboardOutput), graphql_name="dataOperationsDashboards"
    )
    """result data operations list."""

    next_page_info = sgqlc.types.Field("NextPageInfo", graphql_name="nextPageInfo")
    """pagination information."""


class ListDataQualityDimensionsOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_quality_dimension",)
    data_quality_dimension = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="dataQualityDimension"
    )
    """All supported data quality dimensions."""


class ListDatasetsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("datasets", "next_page_token")
    datasets = sgqlc.types.Field(sgqlc.types.list_of(DatasetEntity), graphql_name="datasets")
    """List of dataset IDs"""

    next_page_token = sgqlc.types.Field(String, graphql_name="nextPageToken")
    """Page token for the next page"""


class ListMonitorTagsOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_count", "tags")
    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total count of the monitor tags in a user's account."""

    tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("TagInfoOutput")), graphql_name="tags"
    )
    """Monitor Tags list."""


class ListProjectsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("projects", "next_page_token")
    projects = sgqlc.types.Field(sgqlc.types.list_of("ProjectEntity"), graphql_name="projects")
    """List of project IDs"""

    next_page_token = sgqlc.types.Field(String, graphql_name="nextPageToken")
    """Page token for the next page"""


class ListTagsOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_count", "tags")
    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total count of the tags in a user's account."""

    tags = sgqlc.types.Field(sgqlc.types.list_of("TagObjectOutput"), graphql_name="tags")
    """Tags list."""


class LoginDetails(sgqlc.types.Type):
    """Login information"""

    __schema__ = schema
    __field_names__ = ("sso",)
    sso = sgqlc.types.Field(sgqlc.types.non_null("SsoDetails"), graphql_name="sso")
    """SSO information"""


class LogsIntegrationOutput(sgqlc.types.Type):
    """A Logs integration (for monitor execution logging)"""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "webhook_url",
        "integration_type",
        "headers",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(String, graphql_name="integrationName")
    """A short name to identify the integration"""

    webhook_url = sgqlc.types.Field(String, graphql_name="webhookUrl")
    """The URL to post messages to"""

    integration_type = sgqlc.types.Field(
        sgqlc.types.non_null(LogsIntegrationType), graphql_name="integrationType"
    )
    """Type log integration to use"""

    headers = sgqlc.types.Field(sgqlc.types.list_of("WebhookHeader"), graphql_name="headers")
    """Header key/value to use when sending webhook request"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the integration"""


class LookerDashboardTileRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tile_id", "tile_title")
    tile_id = sgqlc.types.Field(String, graphql_name="tileId")

    tile_title = sgqlc.types.Field(String, graphql_name="tileTitle")


class ManyToManyChange(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("operation", "object_names")
    operation = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="operation")
    """add/delete"""

    object_names = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="objectNames"
    )
    """Related objects"""


class MatchAndCreateBiWarehouseSources(sgqlc.types.Type):
    """Create or update a BI warehouse source. If BI warehouse source
    details are provided in the bi_warehouse_sources parameter then
    those are saved. Else, details are pulled from the BI APIs,
    matched with warehouses in Monte Carlo and details saved only if
    there is a full match.
    """

    __schema__ = schema
    __field_names__ = ("matching_bi_warehouse_sources",)
    matching_bi_warehouse_sources = sgqlc.types.Field(
        "MatchingBiWarehouseSources", graphql_name="matchingBiWarehouseSources"
    )


class MatchingBiWarehouseSources(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "match_successful",
        "bi_warehouse_sources",
        "raw_bi_warehouse_connections",
        "raw_warehouse_connections",
    )
    match_successful = sgqlc.types.Field(Boolean, graphql_name="matchSuccessful")
    """Indicates whether all BI source warehouses could be matched with a
    warehouse stored in MC. Only true if all BI source warehouses
    could be matched.
    """

    bi_warehouse_sources = sgqlc.types.Field(
        sgqlc.types.list_of(BiWarehouseSources), graphql_name="biWarehouseSources"
    )
    """Details of matched warehouses."""

    raw_bi_warehouse_connections = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="rawBiWarehouseConnections"
    )
    """Raw response from customer's BI system listing the warehouses it
    is connected to. Only set if match_successful is False.
    """

    raw_warehouse_connections = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="rawWarehouseConnections"
    )
    """Details of warehouses that are in MC. Only set if match_successful
    is False.
    """


class McSqlResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("errors", "sql", "fragments")
    errors = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Error))),
        graphql_name="errors",
    )

    sql = sgqlc.types.Field(String, graphql_name="sql")

    fragments = sgqlc.types.Field(GenericScalar, graphql_name="fragments")


class MconCountPair(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "count")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")


class MconMonitorPair(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "monitor_name", "table_tags")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    monitor_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="monitorName")

    table_tags = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="tableTags",
    )


class MconRuleIdPair(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "monitoring_rule_id")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    monitoring_rule_id = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="monitoringRuleId"
    )


class MconsMonitorsCountPair(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcons_count", "monitors_count")
    mcons_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="mconsCount")

    monitors_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="monitorsCount")


class MergeAlerts(sgqlc.types.Type):
    """Merge alerts together"""

    __schema__ = schema
    __field_names__ = ("alert",)
    alert = sgqlc.types.Field("Alert", graphql_name="alert")
    """The updated alert"""


class MetricAggregationOutputType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metric", "aggregation")
    metric = sgqlc.types.Field(String, graphql_name="metric")
    """Query performance metric"""

    aggregation = sgqlc.types.Field(String, graphql_name="aggregation")
    """Metric aggregation function"""


class MetricAnomalyCorrelation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field", "metric", "correlations")
    field = sgqlc.types.Field(String, graphql_name="field")

    metric = sgqlc.types.Field(String, graphql_name="metric")

    correlations = sgqlc.types.Field(
        sgqlc.types.list_of(FieldValueCorrelation), graphql_name="correlations"
    )


class MetricAnomalyCorrelationV2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field", "metric", "data", "has_strong_correlations")
    field = sgqlc.types.Field(String, graphql_name="field")

    metric = sgqlc.types.Field(String, graphql_name="metric")

    data = sgqlc.types.Field(sgqlc.types.list_of(FieldValueCorrelation), graphql_name="data")

    has_strong_correlations = sgqlc.types.Field(Boolean, graphql_name="hasStrongCorrelations")


class MetricCorrelationResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metric_anomalies", "metric_anomalies_v2")
    metric_anomalies = sgqlc.types.Field(
        sgqlc.types.list_of(MetricAnomalyCorrelation), graphql_name="metricAnomalies"
    )

    metric_anomalies_v2 = sgqlc.types.Field(
        sgqlc.types.list_of(MetricAnomalyCorrelationV2), graphql_name="metricAnomaliesV2"
    )


class MetricDimensions(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("rank", "label", "sequence_number", "data_source_uuid")
    rank = sgqlc.types.Field(Float, graphql_name="rank")

    label = sgqlc.types.Field(String, graphql_name="label")

    sequence_number = sgqlc.types.Field(Int, graphql_name="sequenceNumber")

    data_source_uuid = sgqlc.types.Field(UUID, graphql_name="dataSourceUuid")


class MetricEventGroup(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("group_key", "group_metadata")
    group_key = sgqlc.types.Field(
        sgqlc.types.non_null("MetricEventGroupKey"), graphql_name="groupKey"
    )
    """Attributes that uniquely defines an event group"""

    group_metadata = sgqlc.types.Field(
        sgqlc.types.non_null("MetricEventGroupMetadata"), graphql_name="groupMetadata"
    )
    """Additional metadata of the event group (not used to create the
    event group)
    """


class MetricEventGroupKey(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("monitor_uuid", "metric")
    monitor_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="monitorUuid")
    """The UUID of the metric monitor of the grouped events"""

    metric = sgqlc.types.Field(String, graphql_name="metric")
    """The name of the metric of the grouped events"""


class MetricEventGroupMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("newest_event_generated_time", "group_title", "tables", "total_events")
    newest_event_generated_time = sgqlc.types.Field(
        DateTime, graphql_name="newestEventGeneratedTime"
    )

    group_title = sgqlc.types.Field(String, graphql_name="groupTitle")

    tables = sgqlc.types.Field(sgqlc.types.list_of("WarehouseTable"), graphql_name="tables")
    """All tables associated with the metric event group"""

    total_events = sgqlc.types.Field(Int, graphql_name="totalEvents")
    """Total number of events in the event group"""


class MetricInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("display_name", "metric", "metric_data_type")
    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")

    metric = sgqlc.types.Field(sgqlc.types.non_null(AggregateMetricType), graphql_name="metric")

    metric_data_type = sgqlc.types.Field(
        sgqlc.types.non_null(MetricDataType), graphql_name="metricDataType"
    )


class MetricMeasurement(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("timestamp", "value")
    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")


class MetricMonitorSelectExpression(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "metric_monitor", "expression", "data_type", "is_raw_column_name")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    metric_monitor = sgqlc.types.Field(
        sgqlc.types.non_null("ComparisonMonitorResponse"), graphql_name="metricMonitor"
    )

    expression = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="expression")

    data_type = sgqlc.types.Field(
        MetricMonitorSelectExpressionModelDataType, graphql_name="dataType"
    )

    is_raw_column_name = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isRawColumnName"
    )


class MetricMonitoringConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("MetricMonitoringEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class MetricMonitoringEdge(sgqlc.types.Type):
    """A Relay edge containing a `MetricMonitoring` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("MetricMonitoring", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class MetricSampling(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("columns", "rows", "matches", "query", "has_error")
    columns = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="columns")

    rows = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.list_of(String)), graphql_name="rows")

    matches = sgqlc.types.Field(sgqlc.types.list_of(ConditionMatches), graphql_name="matches")

    query = sgqlc.types.Field(String, graphql_name="query")

    has_error = sgqlc.types.Field(Boolean, graphql_name="hasError")


class MetricUnit(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("singular", "plural")
    singular = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="singular")
    """Singular unit. For example, row"""

    plural = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="plural")
    """Plural unit. For example, rows"""


class Metrics(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metrics", "is_partial_date_range", "metrics_json")
    metrics = sgqlc.types.Field(sgqlc.types.list_of("TableMetricV2"), graphql_name="metrics")
    """List of metrics. Deprecated: Use metricsJson for better
    performance
    """

    is_partial_date_range = sgqlc.types.Field(Boolean, graphql_name="isPartialDateRange")

    metrics_json = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metricsJson")
    """List of metrics, in JSON representation"""


class MigrateCollectorResources(sgqlc.types.Type):
    """Migrate resources (warehouses, BI) from one data collector to
    another
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """If the migration was successful"""


class MigrateConnectionFromSnowflakeAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if the connection was migrated successfully."""


class MigrateConnectionToSnowflakeAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if the connection was migrated successfully."""


class MonitorAtRisk(sgqlc.types.Type):
    """Monitor that could be affected if this table monitor is deleted"""

    __schema__ = schema
    __field_names__ = ("uuid", "description", "creator", "created_time", "monitor_type")
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Monitor UUID"""

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")
    """Monitor description"""

    creator = sgqlc.types.Field(String, graphql_name="creator")
    """ID of user who created the monitor"""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """When the monitor was created"""

    monitor_type = sgqlc.types.Field(
        sgqlc.types.non_null(UserDefinedMonitors), graphql_name="monitorType"
    )
    """Type of monitor"""


class MonitorAtRiskConnection(sgqlc.types.relay.Connection):
    """Relay connection for monitors at risk"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("MonitorAtRiskEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class MonitorAtRiskEdge(sgqlc.types.Type):
    """A Relay edge containing a `MonitorAtRisk` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(MonitorAtRisk, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class MonitorBootstrap(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "state",
        "exceptions_detail",
        "skip_reason",
        "started_at",
        "finished_at",
        "days_loaded",
        "estimated_seconds_remaining",
        "progress_percent",
    )
    state = sgqlc.types.Field(
        sgqlc.types.non_null(MetricMonitoringBootstrapState), graphql_name="state"
    )
    """State of the monitor bootstrapping process."""

    exceptions_detail = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JobExecutionException)),
        graphql_name="exceptionsDetail",
    )
    """Exceptions that were captured while the bootstrap is in an error
    state.
    """

    skip_reason = sgqlc.types.Field(String, graphql_name="skipReason")
    """Reason why the historical data loading was skipped, if the status
    is SKIPPED_HISTORY.
    """

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Indicates when historical data loading started."""

    finished_at = sgqlc.types.Field(DateTime, graphql_name="finishedAt")
    """Indicates when historical data loading finished."""

    days_loaded = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="daysLoaded")
    """Number of days of historical data that have been loaded."""

    estimated_seconds_remaining = sgqlc.types.Field(Int, graphql_name="estimatedSecondsRemaining")
    """Estimated time remaining for the historical data loading to
    complete, in seconds.
    """

    progress_percent = sgqlc.types.Field(Int, graphql_name="progressPercent")
    """Progress for loading historical data."""


class MonitorComment(sgqlc.types.Type):
    """A comment on a monitor"""

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "monitor_uuid",
        "text",
        "created_by",
        "created_time",
        "updated_time",
        "mentioned_users",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique identifier for the comment"""

    monitor_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="monitorUuid")
    """UUID of the monitor this comment belongs to"""

    text = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="text")
    """The comment text content"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """User who created the comment"""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """When the comment was created"""

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")
    """When the comment was last updated"""

    mentioned_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("User")), graphql_name="mentionedUsers"
    )
    """Users that are mentioned in the comment"""


class MonitorConfiguration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_field", "aggregation_type", "lookback_days")
    time_field = sgqlc.types.Field(String, graphql_name="timeField")
    """Time field to use for the monitor"""

    aggregation_type = sgqlc.types.Field(MonitorAggTimeInterval, graphql_name="aggregationType")
    """Day or Hour"""

    lookback_days = sgqlc.types.Field(Int, graphql_name="lookbackDays")
    """The history days for the monitor"""


class MonitorDashboardData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "total_monitor_count",
        "paused_count",
        "snoozed_count",
        "active_count",
        "training_count",
        "misconfigured_count",
        "error_count",
        "in_progress_count",
        "no_status_count",
    )
    total_monitor_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="totalMonitorCount"
    )
    """Total count of monitors actively in MC account"""

    paused_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="pausedCount")
    """Total number of paused monitors"""

    snoozed_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="snoozedCount")
    """Total number of snoozed monitors"""

    active_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="activeCount")
    """Total count of monitors with active status"""

    training_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="trainingCount")
    """Total count of monitors with training status"""

    misconfigured_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="misconfiguredCount"
    )
    """Total count of monitors with misconfigured status"""

    error_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="errorCount")
    """Total count of monitors with error status"""

    in_progress_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="inProgressCount")
    """Total number of monitors currently running"""

    no_status_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="noStatusCount")
    """Total number of monitors with state no status"""


class MonitorDataSource(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "connection_uuid",
        "custom_sql",
        "type",
        "schema",
        "tables",
        "transforms",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    connection_uuid = sgqlc.types.Field(UUID, graphql_name="connectionUuid")
    """The connection uuid"""

    custom_sql = sgqlc.types.Field(String, graphql_name="customSql")

    type = sgqlc.types.Field(sgqlc.types.non_null(DataSourceType), graphql_name="type")

    schema = sgqlc.types.Field(DataSourceSchema, graphql_name="schema")

    tables = sgqlc.types.Field(sgqlc.types.list_of("WarehouseTable"), graphql_name="tables")

    transforms = sgqlc.types.Field(sgqlc.types.list_of("Transform"), graphql_name="transforms")


class MonitorDataset(sgqlc.types.Type):
    """Datasets referenced by monitors, grouped by dataset name"""

    __schema__ = schema
    __field_names__ = ("display_name", "mcons")
    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Dataset name"""

    mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="mcons",
    )
    """List of MCONs for the datasets with this name"""


class MonitorLabel(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("label",)
    label = sgqlc.types.Field(String, graphql_name="label")
    """The monitor label name"""


class MonitorLabelObject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "label",
        "created_by",
        "default_failure_audience",
        "monitors",
        "monitor_count",
        "notification_count",
        "used_in_mac",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique identifier of a monitor label"""

    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")
    """Monitor label name"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Monitor label creator"""

    default_failure_audience = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="defaultFailureAudience"
    )
    """When creating a new monitor, this audience should be included, by
    default, in the monitor's list of failure_audiences
    """

    monitors = sgqlc.types.Field(
        sgqlc.types.list_of("Monitor"),
        graphql_name="monitors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """List of monitors using this label

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    monitor_count = sgqlc.types.Field(Int, graphql_name="monitorCount")
    """The number of monitors using this label"""

    notification_count = sgqlc.types.Field(Int, graphql_name="notificationCount")
    """The number of notifications using this label"""

    used_in_mac = sgqlc.types.Field(Boolean, graphql_name="usedInMac")
    """Flag for whether any MaC monitors use this label"""


class MonitorLimits(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "max_time_series",
        "max_time_series_hourly",
        "max_time_series_daily",
        "max_time_series_weekly",
        "max_time_series_monthly",
    )
    max_time_series = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="maxTimeSeries")
    """Time series limit"""

    max_time_series_hourly = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxTimeSeriesHourly"
    )
    """Hourly time series limit"""

    max_time_series_daily = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxTimeSeriesDaily"
    )
    """Daily time series limit"""

    max_time_series_weekly = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxTimeSeriesWeekly"
    )
    """Weekly time series limit"""

    max_time_series_monthly = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxTimeSeriesMonthly"
    )
    """Monthly time series limit"""


class MonitorProject(sgqlc.types.Type):
    """Projects referenced by monitors, grouped by project name"""

    __schema__ = schema
    __field_names__ = ("display_name", "mcons")
    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Project name"""

    mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="mcons",
    )
    """List of MCONs for the projects with this name"""


class MonitorQueries(sgqlc.types.Type):
    """A monitor query"""

    __schema__ = schema
    __field_names__ = ("queries",)
    queries = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="queries")
    """The SQL queries executed by the monitor"""


class MonitorQueriesResults(sgqlc.types.Type):
    """Result of executing a monitor query for test purposes"""

    __schema__ = schema
    __field_names__ = ("queries",)
    queries = sgqlc.types.Field(sgqlc.types.list_of("SQLResponse"), graphql_name="queries")
    """The SQL queries results"""


class MonitorRecommendationsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("monitor_recommendations",)
    monitor_recommendations = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(RecommendationConfigInterface))
        ),
        graphql_name="monitorRecommendations",
    )


class MonitorSamplingConfig(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("percentage", "count")
    percentage = sgqlc.types.Field(Float, graphql_name="percentage")

    count = sgqlc.types.Field(Int, graphql_name="count")


class MonitorSchedulingConfiguration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("schedule_type", "interval_minutes", "start_time")
    schedule_type = sgqlc.types.Field(String, graphql_name="scheduleType")
    """One of fixed/dynamic or None if cannot decide automatically"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Number of minutes between monitor runs is schedule type is fixed"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Date to start the monitor if schedule type is fixed"""


class MonitorScoreTrendType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("day", "pass_percentage")
    day = sgqlc.types.Field(String, graphql_name="day")
    """The day of the score trend"""

    pass_percentage = sgqlc.types.Field(Float, graphql_name="passPercentage")
    """Pass percentage for the day"""


class MonitorSqlBlocks(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("alert_condition", "where_condition", "group_by", "agent_span")
    alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null("FilterGroup"), graphql_name="alertCondition"
    )

    where_condition = sgqlc.types.Field(
        sgqlc.types.non_null("FilterGroup"), graphql_name="whereCondition"
    )

    group_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface))),
        graphql_name="groupBy",
    )

    agent_span = sgqlc.types.Field(sgqlc.types.non_null("FilterGroup"), graphql_name="agentSpan")


class MonitorSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "resources",
        "stats",
        "categories",
        "hourly_stats",
        "json_schema",
        "custom_sql",
        "table_metric",
    )
    resources = sgqlc.types.Field("TableResources", graphql_name="resources")

    stats = sgqlc.types.Field(Int, graphql_name="stats")

    categories = sgqlc.types.Field(Int, graphql_name="categories")

    hourly_stats = sgqlc.types.Field(Int, graphql_name="hourlyStats")
    """Hourly stats monitors (DEPRECATED)"""

    json_schema = sgqlc.types.Field(Int, graphql_name="jsonSchema")

    custom_sql = sgqlc.types.Field(Int, graphql_name="customSql")

    table_metric = sgqlc.types.Field(Int, graphql_name="tableMetric")


class MonitorTable(sgqlc.types.Type):
    """Tables referenced by monitors, grouped by table identifier"""

    __schema__ = schema
    __field_names__ = ("display_name", "mcons")
    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Table identifier"""

    mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="mcons",
    )
    """List of MCONs for the tables with this identifier"""


class MonitorTypeCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("monitor_type", "count")
    monitor_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="monitorType")

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")


class MonitorTypeCountsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("results", "total_count", "offset", "limit")
    results = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(MonitorTypeCount)), graphql_name="results"
    )

    total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount")

    offset = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="offset")

    limit = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="limit")


class MonitorWarehouse(sgqlc.types.Type):
    """Warehouse assets referenced by monitors, grouped by name"""

    __schema__ = schema
    __field_names__ = ("display_name", "mcons")
    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Warehouse name"""

    mcons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="mcons",
    )
    """List of MCONs for the warehouses with this name"""


class MonitoredTableRuleJobStatusObject(sgqlc.types.Type):
    """Job status for updating monitored table rules"""

    __schema__ = schema
    __field_names__ = ("created_time", "updated_time", "uuid", "tables_updated", "status")
    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """Time when the job was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """Time when the job was last updated"""

    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """Job ID for the job"""

    tables_updated = sgqlc.types.Field(Int, graphql_name="tablesUpdated")
    """Number of tables updated by the job"""

    status = sgqlc.types.Field(MonitoredTableRuleJobStatus, graphql_name="status")
    """Status of the job"""


class MonitoredTableRuleListUpdateOutput(sgqlc.types.Type):
    """Output of the async update of the monitored table rules"""

    __schema__ = schema
    __field_names__ = ("rules", "job_id")
    rules = sgqlc.types.Field(sgqlc.types.list_of("MonitoredTableRuleObject"), graphql_name="rules")
    """The complete list of rules for deciding which tables are monitored
    within the given project & dataset scope
    """

    job_id = sgqlc.types.Field(UUID, graphql_name="jobId")
    """The job ID for the async update"""


class MonitoredTableRuleObject(sgqlc.types.Type):
    """Rule for deciding which tables are monitored"""

    __schema__ = schema
    __field_names__ = (
        "id",
        "dataset",
        "is_exclude",
        "project",
        "rule_type",
        "table_rule_attribute",
        "table_rule_text",
        "source",
        "monitored_rule_type",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Schema/Dataset where rule applies"""

    is_exclude = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExclude")
    """Is this an exclude rule?"""

    project = sgqlc.types.Field(String, graphql_name="project")
    """Project/database scope of the rule"""

    rule_type = sgqlc.types.Field(MonitoredTableRuleType, graphql_name="ruleType")
    """Type of rule"""

    table_rule_attribute = sgqlc.types.Field(
        MonitoredTableRuleTableAttribute, graphql_name="tableRuleAttribute"
    )
    """Table attribute that the rule matches against"""

    table_rule_text = sgqlc.types.Field(String, graphql_name="tableRuleText")
    """Either a simple string value or a JSON string (for tag rules)"""

    source = sgqlc.types.Field(String, graphql_name="source")
    """Source of the rule"""

    monitored_rule_type = sgqlc.types.Field(MonitoredRuleType, graphql_name="monitoredRuleType")
    """Monitoring rule type"""


class MonitoringRuleData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "warehouse_uuid",
        "warehouse_name",
        "project_name",
        "dataset",
        "is_exclude",
        "rule_type",
        "table_rule_attribute",
        "table_rule_text",
        "is_disabled",
        "source",
        "monitored_rule_type",
        "created_by_id",
        "last_update_user_id",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="id")

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="warehouseUuid")

    warehouse_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="warehouseName")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    dataset = sgqlc.types.Field(String, graphql_name="dataset")

    is_exclude = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExclude")

    rule_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ruleType")

    table_rule_attribute = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="tableRuleAttribute"
    )

    table_rule_text = sgqlc.types.Field(String, graphql_name="tableRuleText")

    is_disabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDisabled")

    source = sgqlc.types.Field(String, graphql_name="source")

    monitored_rule_type = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="monitoredRuleType"
    )

    created_by_id = sgqlc.types.Field(Int, graphql_name="createdById")

    last_update_user_id = sgqlc.types.Field(Int, graphql_name="lastUpdateUserId")


class MonteCarloConfigTemplateConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("MonteCarloConfigTemplateEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class MonteCarloConfigTemplateDeleteResponse(sgqlc.types.Type):
    """Monte Carlo Config Template Delete Response"""

    __schema__ = schema
    __field_names__ = ("num_deleted", "changes_applied")
    num_deleted = sgqlc.types.Field(Int, graphql_name="numDeleted")
    """Number of resources deleted"""

    changes_applied = sgqlc.types.Field(Boolean, graphql_name="changesApplied")
    """Changes applied?"""


class MonteCarloConfigTemplateEdge(sgqlc.types.Type):
    """A Relay edge containing a `MonteCarloConfigTemplate` and its
    cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("MonteCarloConfigTemplate", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class MonteCarloConfigTemplateExportResponse(sgqlc.types.Type):
    """Monte Carlo Config Template Export Response"""

    __schema__ = schema
    __field_names__ = ("config_template_as_yaml", "errors")
    config_template_as_yaml = sgqlc.types.Field(String, graphql_name="configTemplateAsYaml")
    """Config Template as YAML"""

    errors = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="errors")
    """Errors encountered"""


class MonteCarloConfigTemplateUpdateAsyncResponse(sgqlc.types.Type):
    """Monte Carlo Config Template Update Async Response"""

    __schema__ = schema
    __field_names__ = ("update_uuid", "errors_as_json", "warnings_as_json")
    update_uuid = sgqlc.types.Field(UUID, graphql_name="updateUuid")
    """The UUID of the requested update. Used to poll for the status of
    the update. Null if the update request is invalid.
    """

    errors_as_json = sgqlc.types.Field(String, graphql_name="errorsAsJson")
    """Errors encountered"""

    warnings_as_json = sgqlc.types.Field(String, graphql_name="warningsAsJson")
    """Warnings encountered"""


class MonteCarloConfigTemplateUpdateAsyncState(sgqlc.types.Type):
    """Monte Carlo Config Template Update Async State"""

    __schema__ = schema
    __field_names__ = (
        "resource_modifications",
        "changes_applied",
        "errors_as_json",
        "warnings_as_json",
        "info_as_json",
        "state",
    )
    resource_modifications = sgqlc.types.Field(
        sgqlc.types.list_of("ResourceModification"), graphql_name="resourceModifications"
    )
    """List of resource modifications"""

    changes_applied = sgqlc.types.Field(Boolean, graphql_name="changesApplied")
    """Changes applied?"""

    errors_as_json = sgqlc.types.Field(String, graphql_name="errorsAsJson")
    """Errors encountered"""

    warnings_as_json = sgqlc.types.Field(String, graphql_name="warningsAsJson")
    """Warnings encountered"""

    info_as_json = sgqlc.types.Field(String, graphql_name="infoAsJson")
    """Informational messages"""

    state = sgqlc.types.Field(sgqlc.types.non_null(State), graphql_name="state")
    """State of the async update"""


class MonteCarloConfigTemplateUpdateResponse(sgqlc.types.Type):
    """Monte Carlo Config Template Update Response"""

    __schema__ = schema
    __field_names__ = (
        "resource_modifications",
        "changes_applied",
        "errors_as_json",
        "warnings_as_json",
        "info_as_json",
    )
    resource_modifications = sgqlc.types.Field(
        sgqlc.types.list_of("ResourceModification"), graphql_name="resourceModifications"
    )
    """List of resource modifications"""

    changes_applied = sgqlc.types.Field(Boolean, graphql_name="changesApplied")
    """Changes applied?"""

    errors_as_json = sgqlc.types.Field(String, graphql_name="errorsAsJson")
    """Errors encountered"""

    warnings_as_json = sgqlc.types.Field(String, graphql_name="warningsAsJson")
    """Warnings encountered"""

    info_as_json = sgqlc.types.Field(String, graphql_name="infoAsJson")
    """Informational messages"""


class MonteCarloStatusMapping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("servicenow_incident_state", "incident_feedback")
    servicenow_incident_state = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="servicenowIncidentState"
    )

    incident_feedback = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="incidentFeedback",
    )


class MsTeamsChannel(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "team_id", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Channel ID (MS-specific)"""

    team_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="teamId")
    """ID of the team the channel belongs to"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Human readable channel name"""


class MsTeamsChannelList(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("channels",)
    channels = sgqlc.types.Field(sgqlc.types.list_of(MsTeamsChannel), graphql_name="channels")


class MsTeamsInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "name", "team_link", "team_id")
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the installation"""

    team_link = sgqlc.types.Field(String, graphql_name="teamLink")

    team_id = sgqlc.types.Field(String, graphql_name="teamId")


class MsTeamsInstallationList(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("install_link", "installations")
    install_link = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="installLink")

    installations = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(MsTeamsInstallation)), graphql_name="installations"
    )


class Mutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "create_or_update_custom_dashboard",
        "delete_custom_dashboard",
        "add_or_update_custom_dashboard_widget",
        "delete_custom_dashboard_widget",
        "update_platform_service",
        "create_or_update_agent_trace_table",
        "delete_agent_trace_table",
        "link_slack_app_installation",
        "create_logs_integration",
        "update_logs_integration",
        "delete_logs_integration",
        "generate_report",
        "create_datadog_integration",
        "update_datadog_integration",
        "delete_datadog_integration",
        "create_datadog_incident_for_alert",
        "link_datadog_incident_for_alert",
        "unlink_datadog_incident_for_alert",
        "create_or_update_table_monitor",
        "pause_table_monitor",
        "delete_table_monitor",
        "create_single_table_monitoring_notification",
        "update_monitor_tags",
        "bulk_add_monitor_tags",
        "delete_monitor_tag",
        "update_monitor_data_quality_dimension",
        "bulk_add_monitor_data_quality_dimension",
        "create_or_update_tag",
        "create_or_update_tag_assignments",
        "create_or_update_data_operations_dashboard",
        "delete_data_operations_dashboard",
        "create_or_update_validation",
        "caas_link_collection_resources",
        "caas_update_collection_node_parameters",
        "caas_update_collection_node_env",
        "caas_update_collection_storage_parameters",
        "caas_update_collection_storage_version",
        "caas_update_collection_node_version",
        "trigger_platform_migration",
        "trigger_platform_migration_test",
        "trigger_migration_test",
        "add_platform_service",
        "restore_collection_storage",
        "connect_platform_service_to_legacy_bucket",
        "connect_platform_service_to_existing_bucket",
        "connect_platform_to_existing_agent",
        "caas_update_collection_storage_link",
        "caas_update_collection_storage_encryption",
        "refresh_entitlements",
        "run_table_monitor_validation",
        "test_updated_credentials_v2",
        "update_credentials_v2",
        "update_self_hosted_credentials_v2",
        "update_dbt_cloud_credentials_v2_mutation",
        "update_transactional_db_credentials_v2",
        "update_big_query_credentials_v2",
        "update_tableau_credentials_v2",
        "update_looker_credentials_v2",
        "update_looker_git_auth_credentials_v2",
        "update_power_bi_credentials_v2",
        "update_snowflake_credentials_v2",
        "update_redshift_credentials_v2",
        "update_databricks_metastore_sql_warehouse_credentials_v2",
        "update_databricks_sql_warehouse_credentials_v2",
        "update_azure_data_factory_credentials_v2",
        "update_pinecone_credentials_v2",
        "create_or_update_data_explorer_dashboard",
        "delete_data_explorer_dashboard",
        "create_or_update_data_explorer_comparison_dashboard",
        "delete_data_explorer_comparison_dashboard",
        "create_webex_integration",
        "update_webex_integration",
        "delete_webex_integration",
        "update_monitored_table_rule_list",
        "update_monitored_table_rule_list_async",
        "add_monitored_table_rule_async",
        "toggle_performance_dashboard_for_domain_restricted_users",
        "create_or_update_agent",
        "delete_agent",
        "upgrade_agent",
        "update_agent_parameters",
        "restart_agent",
        "cleanup_azure_agent_tasks",
        "migrate_connection_to_snowflake_agent",
        "migrate_connection_from_snowflake_agent",
        "create_tableau_asset_warning",
        "update_tableau_asset_warning",
        "generate_dc_upgrade_template",
        "delete_data_product",
        "delete_data_product_v2",
        "create_or_update_data_product",
        "create_or_update_data_product_v2",
        "update_data_product_sharing",
        "toggle_data_product_monitoring",
        "link_ms_teams_installation",
        "link_github_app_installation",
        "register_github_app_installation_request",
        "update_github_installation",
        "delete_github_installation",
        "register_gitlab_app",
        "link_gitlab_app",
        "delete_gitlab_installation",
        "select_gitlab_projects",
        "update_gitlab_installation",
        "create_azure_devops_installation",
        "update_azure_devops_installation",
        "link_azure_devops_installation",
        "delete_azure_devops_installation",
        "set_azure_devops_source_selections",
        "update_data_share",
        "test_confluent_kafka_credentials",
        "test_confluent_kafka_connect_credentials",
        "test_msk_kafka_credentials",
        "test_msk_kafka_connect_credentials",
        "test_self_hosted_kafka_credentials",
        "test_self_hosted_kafka_connect_credentials",
        "add_streaming_system",
        "add_streaming_connection",
        "delete_streaming_system",
        "delete_streaming_cluster",
        "update_streaming_system_name",
        "update_streaming_cluster_name",
        "toggle_size_collection",
        "create_mcp_integration_key",
        "delete_mcp_integration_key",
        "create_opsgenie_integration",
        "update_opsgenie_integration",
        "update_opsgenie_integration_webhook_secret",
        "delete_opsgenie_integration",
        "link_opsgenie_incident",
        "unlink_opsgenie_incident",
        "relink_opsgenie_incident",
        "create_pagerduty_service_integration",
        "update_pagerduty_service_integration",
        "update_pagerduty_service_integration_webhook_secret",
        "delete_pagerduty_service_integration",
        "enable_automated_volume_change_table_monitor",
        "enable_explicit_volume_change_table_monitor",
        "disable_volume_change_table_monitor",
        "enable_automated_ucs_table_monitor",
        "enable_explicit_ucs_table_monitor",
        "disable_ucs_table_monitor",
        "enable_automated_freshness_table_monitor",
        "enable_explicit_freshness_table_monitor",
        "disable_freshness_table_monitor",
        "create_servicenow_integration",
        "update_servicenow_integration",
        "delete_servicenow_integration",
        "create_servicenow_incident_for_alert",
        "link_servicenow_incident_for_alert",
        "unlink_servicenow_incident_for_alert",
        "create_azure_devops_integration",
        "update_azure_devops_integration",
        "link_azure_devops_integration",
        "delete_azure_devops_integration",
        "create_azure_devops_work_item_for_alert",
        "link_azure_devops_work_item_for_alert",
        "unlink_azure_devops_work_item_for_alert",
        "create_jira_integration",
        "update_jira_integration",
        "update_jira_integration_webhook_secret",
        "delete_jira_integration",
        "create_jira_ticket_for_incident",
        "create_jira_ticket_for_alert",
        "link_jira_ticket_for_incident",
        "link_jira_ticket_for_alert",
        "unlink_jira_ticket_for_incident",
        "unlink_jira_ticket_for_alert",
        "create_or_update_notification_setting",
        "create_or_update_recipient_name",
        "delete_notification_settings",
        "delete_recipient_name",
        "create_or_update_audience",
        "create_or_update_audience_notification_setting",
        "delete_audience_notification_setting",
        "create_or_update_audience_routing_rule",
        "delete_audience_routing_rule",
        "set_default_failure_audiences",
        "set_pii_filter_status",
        "update_pii_filtering_preferences",
        "update_monitor_name",
        "update_monitor_description",
        "update_monitor_notes",
        "update_monitor_labels",
        "run_monitor",
        "update_monitors_priorities",
        "update_monitors_schedules",
        "pause_monitors",
        "delete_monitors",
        "run_monitors",
        "create_or_update_monitor_comment",
        "delete_monitor_comment",
        "create_custom_user",
        "create_unified_user_assignment",
        "delete_unified_user_assignment",
        "send_dbt_artifacts_event",
        "set_group_repetitive_dbt_model_failures",
        "set_group_repetitive_dbt_test_failures",
        "set_group_repetitive_dbt_test_warnings",
        "set_group_repetitive_dbt_snapshot_failures",
        "set_group_repetitive_dbt_seed_failures",
        "set_project_generate_incidents_for_model_failures",
        "set_project_generate_alerts_for_model_failures",
        "set_project_generate_incidents_for_test_failures",
        "set_project_generate_alerts_for_test_failures",
        "set_project_generate_incidents_for_test_warnings",
        "set_project_generate_alerts_for_test_warnings",
        "set_project_generate_alerts_for_snapshot_failures",
        "set_project_generate_alerts_for_seed_failures",
        "set_job_generates_incidents",
        "set_job_generates_alerts",
        "snooze_dbt_node",
        "unsnooze_dbt_node",
        "update_dbt_project_info",
        "create_or_update_monte_carlo_config_template",
        "create_or_update_monte_carlo_config_template_async",
        "delete_monte_carlo_config_template",
        "convert_ui_monitors_to_config_template",
        "convert_config_template_to_ui_monitors",
        "set_sensitivity",
        "add_to_collection_block_list",
        "remove_from_collection_block_list",
        "modify_collection_block_list",
        "add_allow_list_entry",
        "delete_allow_list_entry",
        "set_workspaces_allow_list_for_power_bi_reports_collection",
        "set_asset_collection_preferences",
        "delete_asset_collection_preferences",
        "delete_data_maintenance_entry",
        "create_or_update_data_maintenance_entry",
        "create_data_maintenance_window_from_holidays",
        "create_custom_rule",
        "create_or_update_custom_rule",
        "create_custom_metric_rule",
        "create_or_update_custom_metric_rule",
        "update_custom_metric_rule_notes",
        "update_custom_metric_severity",
        "trigger_circuit_breaker_rule",
        "trigger_custom_rule",
        "create_or_update_volume_rule",
        "create_or_update_custom_sql_rule",
        "create_or_update_comparison_rule",
        "create_or_update_query_perf_rule",
        "create_or_update_freshness_custom_rule",
        "snooze_custom_rule",
        "unsnooze_custom_rule",
        "snooze_custom_rules",
        "unsnooze_custom_rules",
        "delete_custom_rule",
        "restore_custom_rule",
        "trigger_circuit_breaker_rule_v2",
        "run_sql_rule",
        "run_custom_rules",
        "pause_rule",
        "update_custom_rule_investigation_query",
        "create_or_update_lineage_node",
        "create_or_update_lineage_edge",
        "create_or_update_lineage_node_block_pattern",
        "create_or_update_lineage_node_replacement_rule",
        "create_or_update_lineage_node_collapsing_rule",
        "delete_lineage_node",
        "delete_lineage_node_block_pattern",
        "delete_lineage_node_replacement_rule",
        "delete_lineage_node_collapsing_rule",
        "create_or_update_field_quality_rule",
        "create_or_update_catalog_object_metadata",
        "delete_catalog_object_metadata",
        "create_or_update_object_property",
        "delete_object_property",
        "bulk_create_or_update_object_properties",
        "create_or_update_monitor_label",
        "delete_monitor_label",
        "add_monitors_labels",
        "remove_monitors_labels",
        "create_or_update_custom_sql_template",
        "delete_custom_sql_template",
        "stop_monitor",
        "delete_monitor",
        "create_or_update_monitor",
        "pause_monitor",
        "resume_monitor_bootstrap",
        "pause_monitor_bootstrap",
        "create_or_update_comparison_monitor",
        "create_or_update_metric_monitor",
        "create_or_update_agent_monitor",
        "create_or_update_json_schema_monitor",
        "validate_cron",
        "set_event_detector_feedback",
        "set_event_detector_feedback_by_alert",
        "set_incident_feedback",
        "set_incident_feedback_v2",
        "set_incident_severity",
        "set_alert_severity",
        "create_or_update_incident_comment",
        "create_or_update_alert_comment",
        "set_alert_owner",
        "set_incident_owner",
        "delete_incident_comment",
        "delete_alert_comment",
        "split_incident",
        "split_alert",
        "bulk_update_incidents",
        "bulk_update_alerts",
        "update_alert",
        "send_alert_invite",
        "create_or_update_domain",
        "delete_domain",
        "create_or_update_authorization_group",
        "delete_authorization_group",
        "update_user_authorization_group_membership",
        "create_or_update_auth_provisioning",
        "request_access",
        "create_or_update_resource",
        "match_and_create_bi_warehouse_sources",
        "toggle_disable_sampling",
        "toggle_restrict_sampling",
        "toggle_disable_value_ingestion",
        "toggle_disable_value_sampling_when_testing",
        "toggle_enable_full_distribution_metrics",
        "toggle_warehouse_tags_collection_setting",
        "save_table_importance_stats",
        "set_default_incident_group_interval",
        "set_default_alert_group_interval",
        "set_default_lineage_incident_grouping",
        "set_default_lineage_alert_grouping",
        "toggle_incident_grouping",
        "toggle_alert_grouping",
        "toggle_schema_change_incident_grouping",
        "toggle_schema_change_alert_grouping",
        "toggle_wildcard_aggregation",
        "toggle_create_alerts_in_datasource",
        "set_wildcard_templates",
        "set_custom_sql_sampling_size",
        "create_shared_query",
        "create_or_update_user_settings",
        "create_or_update_user_settings_batch",
        "update_user_state",
        "update_user_persona",
        "update_account_display_assets_search_tags",
        "set_account_name",
        "set_account_billing_plan",
        "set_account_max_time_series",
        "set_warehouse_name",
        "set_etl_container_name",
        "set_connection_name",
        "set_integration_name",
        "create_or_update_saml_identity_provider",
        "delete_saml_identity_provider",
        "invite_users",
        "invite_users_v2",
        "switch_user_account",
        "delete_user_invite",
        "resend_user_invite",
        "remove_user_from_account",
        "disable_user",
        "track_table",
        "upload_credentials",
        "save_slack_credentials",
        "deauthorize_slack_app",
        "test_credentials",
        "test_database_credentials",
        "test_presto_credentials",
        "test_snowflake_credentials",
        "test_hive_credentials",
        "test_s3_credentials",
        "test_glue_credentials",
        "test_athena_credentials",
        "test_looker_git_credentials",
        "test_looker_git_clone_credentials",
        "test_dbt_cloud_credentials",
        "test_bq_credentials",
        "test_spark_credentials",
        "test_databricks_sql_warehouse_credentials",
        "test_self_hosted_credentials",
        "test_tableau_credentials",
        "test_power_bi_credentials",
        "test_fivetran_credentials",
        "toggle_mute_dataset",
        "toggle_mute_table",
        "toggle_mute_datasets",
        "toggle_mute_tables",
        "toggle_mute_with_regex",
        "toggle_slack_reply_warning",
        "toggle_slack_broadcast_updates",
        "toggle_connection_enable",
        "add_connection",
        "add_redshift_consumer_connection",
        "remove_connection",
        "set_connection_deletion_protection",
        "add_bi_connection",
        "update_bi_connection_name",
        "add_etl_connection",
        "toggle_event_config",
        "configure_metadata_events",
        "configure_query_log_events",
        "disable_metadata_events",
        "disable_query_log_events",
        "create_or_update_service_api_token",
        "create_access_token",
        "delete_access_token",
        "generate_collector_template",
        "update_credentials",
        "create_collector_record",
        "cleanup_collector_record",
        "migrate_collector_resources",
        "update_slack_channels",
        "create_integration_key",
        "delete_integration_key",
        "start_databricks_warehouse",
        "add_databricks_connection",
        "save_event_onboarding_data",
        "delete_event_onboarding_data",
        "toggle_account_feature",
        "set_tutorial_state",
        "set_data_lake_catalog_mappings",
        "delete_integration",
        "update_workspace_identifier",
        "update_statement_option",
        "update_daily_usage_alert_config",
        "test_snowflake_credentials_v2",
        "test_redshift_credentials_v2",
        "test_bq_credentials_v2",
        "test_tableau_credentials_v2",
        "test_looker_credentials_v2",
        "test_looker_git_clone_credentials_v2",
        "test_looker_git_auth_credentials_v2",
        "test_power_bi_credentials_v2",
        "test_databricks_sql_warehouse_credentials_v2",
        "test_databricks_metastore_sql_warehouse_credentials_v2",
        "test_airflow_credentials_v2",
        "test_pinecone_credentials",
        "test_transactional_db_credentials",
        "test_informatica_credentials",
        "test_azure_data_factory_credentials",
        "test_self_hosted_credentials_v2",
        "test_dbt_cloud_credentials_v2",
        "upload_airflow_dag_result",
        "upload_airflow_task_result",
        "upload_airflow_sla_misses",
        "merge_alerts",
        "request_alert_access",
        "create_or_update_collibra_integration",
        "delete_collibra_integration",
        "sync_monitors_to_collibra",
        "create_or_update_alation_integration",
        "delete_alation_integration",
        "create_or_update_alation_table_flag",
        "set_etl_job_generates_incidents",
        "set_etl_job_generates_alerts",
        "bulk_set_etl_job_generates_alerts",
        "configure_ai_agent_prompt",
        "create_account_secret",
        "update_account_secret",
        "delete_account_secret",
    )
    create_or_update_custom_dashboard = sgqlc.types.Field(
        CreateOrUpdateDashboard,
        graphql_name="createOrUpdateCustomDashboard",
        args=sgqlc.types.ArgDict(
            (
                ("dashboard_id", sgqlc.types.Arg(UUID, graphql_name="dashboardId", default=None)),
                ("title", sgqlc.types.Arg(String, graphql_name="title", default=None)),
            )
        ),
    )
    """(experimental) Create or update custom dashboard

    Arguments:

    * `dashboard_id` (`UUID`)None
    * `title` (`String`): Title of the dashboard
    """

    delete_custom_dashboard = sgqlc.types.Field(
        DeleteDashboard,
        graphql_name="deleteCustomDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dashboard_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dashboardId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete custom dashboard

    Arguments:

    * `dashboard_id` (`UUID!`)None
    """

    add_or_update_custom_dashboard_widget = sgqlc.types.Field(
        AddOrUpdateCustomDashboardWidget,
        graphql_name="addOrUpdateCustomDashboardWidget",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dashboard_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dashboardId", default=None
                    ),
                ),
                (
                    "data_sources",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(WidgetDataSourceUnionInput)),
                        graphql_name="dataSources",
                        default=None,
                    ),
                ),
                (
                    "height",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="height", default=None),
                ),
                (
                    "options",
                    sgqlc.types.Arg(WidgetOptionsUnionInput, graphql_name="options", default=None),
                ),
                (
                    "order",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="order", default=None),
                ),
                (
                    "title",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="title", default=None
                    ),
                ),
                (
                    "type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CustomDashboardWidgetType),
                        graphql_name="type",
                        default=None,
                    ),
                ),
                ("widget_id", sgqlc.types.Arg(UUID, graphql_name="widgetId", default=None)),
                (
                    "width",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="width", default=None),
                ),
            )
        ),
    )
    """(experimental) Add or update custom dashboard widget

    Arguments:

    * `dashboard_id` (`UUID!`)None
    * `data_sources` (`[WidgetDataSourceUnionInput!]`): Data source
      definitions
    * `height` (`Int!`): Height of the widget inside the dashboard
    * `options` (`WidgetOptionsUnionInput`): Widget specific options
    * `order` (`Int!`): Order of the widget inside the dashboard
    * `title` (`String!`): Title of the widget
    * `type` (`CustomDashboardWidgetType!`): Type of the widget
    * `widget_id` (`UUID`)None
    * `width` (`Int!`): Width of the widget inside the dashboard
    """

    delete_custom_dashboard_widget = sgqlc.types.Field(
        DeleteCustomDashboardWidget,
        graphql_name="deleteCustomDashboardWidget",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dashboard_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dashboardId", default=None
                    ),
                ),
                (
                    "widget_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="widgetId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete custom dashboard widget

    Arguments:

    * `dashboard_id` (`UUID!`)None
    * `widget_id` (`UUID!`)None
    """

    update_platform_service = sgqlc.types.Field(
        "UpdatePlatformService",
        graphql_name="updatePlatformService",
        args=sgqlc.types.ArgDict(
            (
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                (
                    "service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="serviceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Update platform service attributes.

    Arguments:

    * `name` (`String`): New service name
    * `service_uuid` (`UUID!`): UUID of the platform service to update
    """

    create_or_update_agent_trace_table = sgqlc.types.Field(
        CreateOrUpdateAgentTraceTable,
        graphql_name="createOrUpdateAgentTraceTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CreateOrUpdateAgentTraceTableInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update an agent trace table

    Arguments:

    * `input` (`CreateOrUpdateAgentTraceTableInput!`)None
    """

    delete_agent_trace_table = sgqlc.types.Field(
        DeleteAgentTraceTable,
        graphql_name="deleteAgentTraceTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DeleteAgentTraceTableInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete an agent trace table

    Arguments:

    * `input` (`DeleteAgentTraceTableInput!`)None
    """

    link_slack_app_installation = sgqlc.types.Field(
        LinkSlackAppInstallation,
        graphql_name="linkSlackAppInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="state", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Callback API for Slack App Installation Oauth flow

    Arguments:

    * `code` (`String!`): OAuth code from Slack
    * `state` (`String!`): State parameter for OAuth flow
    """

    create_logs_integration = sgqlc.types.Field(
        CreateLogsIntegration,
        graphql_name="createLogsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "headers",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(WebhookHeaderInput),
                        graphql_name="headers",
                        default=None,
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "integration_type",
                    sgqlc.types.Arg(
                        LogsIntegrationType, graphql_name="integrationType", default=None
                    ),
                ),
                (
                    "webhook_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="webhookUrl", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Create a Logs integration (for monitor
    execution logging)

    Arguments:

    * `headers` (`[WebhookHeaderInput]`): List of headers field names
      and value to be used in the HTTP request
    * `integration_name` (`String!`): Integration name
    * `integration_type` (`LogsIntegrationType`): Type of integration,
      defaults to 'default'
    * `webhook_url` (`String!`): The webhook URL
    """

    update_logs_integration = sgqlc.types.Field(
        "UpdateLogsIntegration",
        graphql_name="updateLogsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "headers",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(WebhookHeaderInput),
                        graphql_name="headers",
                        default=None,
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(String, graphql_name="integrationName", default=None),
                ),
                (
                    "integration_type",
                    sgqlc.types.Arg(
                        LogsIntegrationType, graphql_name="integrationType", default=None
                    ),
                ),
                ("webhook_url", sgqlc.types.Arg(String, graphql_name="webhookUrl", default=None)),
            )
        ),
    )
    """(general availability) Update a Logs integration (for monitor
    execution logging)

    Arguments:

    * `headers` (`[WebhookHeaderInput]`): List of headers field names
      and value to be used in the HTTP request
    * `integration_id` (`UUID!`): The integration ID
    * `integration_name` (`String`): Integration name
    * `integration_type` (`LogsIntegrationType`): Type of integration,
      defaults to 'default'
    * `webhook_url` (`String`): The webhook URL
    """

    delete_logs_integration = sgqlc.types.Field(
        DeleteLogsIntegration,
        graphql_name="deleteLogsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Delete a Logs integration (for monitor
    execution logging)

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    generate_report = sgqlc.types.Field(
        GenerateReport,
        graphql_name="generateReport",
        args=sgqlc.types.ArgDict(
            (
                (
                    "report_parameters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ReportArgumentsUnionInput),
                        graphql_name="reportParameters",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Generate a report

    Arguments:

    * `report_parameters` (`ReportArgumentsUnionInput!`)None
    """

    create_datadog_integration = sgqlc.types.Field(
        CreateDatadogIntegration,
        graphql_name="createDatadogIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "api_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="apiKey", default=None
                    ),
                ),
                (
                    "application_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="applicationKey", default=None
                    ),
                ),
                (
                    "default_incident_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultIncidentFields", default=None),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "site",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="site", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create a Datadog integration

    Arguments:

    * `api_key` (`String!`): Datadog API key
    * `application_key` (`String!`): Datadog Application key
    * `default_incident_fields` (`JSONString`): Default values for
      Datadog incident fields
    * `integration_name` (`String!`): Identifying name
    * `site` (`String!`): Datadog site (e.g. datadoghq.com)
    """

    update_datadog_integration = sgqlc.types.Field(
        "UpdateDatadogIntegration",
        graphql_name="updateDatadogIntegration",
        args=sgqlc.types.ArgDict(
            (
                ("api_key", sgqlc.types.Arg(String, graphql_name="apiKey", default=None)),
                (
                    "application_key",
                    sgqlc.types.Arg(String, graphql_name="applicationKey", default=None),
                ),
                (
                    "default_incident_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultIncidentFields", default=None),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "site",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="site", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Update a Datadog integration

    Arguments:

    * `api_key` (`String`): Datadog API key
    * `application_key` (`String`): Datadog Application key
    * `default_incident_fields` (`JSONString`): Default values for
      Datadog incident fields
    * `integration_id` (`UUID!`): The integration ID
    * `integration_name` (`String!`): Identifying name
    * `site` (`String!`): Datadog site (e.g. datadoghq.com)
    """

    delete_datadog_integration = sgqlc.types.Field(
        DeleteDatadogIntegration,
        graphql_name="deleteDatadogIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete a Datadog integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    create_datadog_incident_for_alert = sgqlc.types.Field(
        CreateDatadogIncidentForAlert,
        graphql_name="createDatadogIncidentForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "commander_email",
                    sgqlc.types.Arg(String, graphql_name="commanderEmail", default=None),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("fields", sgqlc.types.Arg(JSONString, graphql_name="fields", default=None)),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "title",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="title", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create a Datadog incident for alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `commander_email` (`String`): Email of the incident commander to
      assign
    * `description` (`String`): Description of the incident
    * `fields` (`JSONString`): Additional incident fields
      (key->value).
    * `integration_id` (`UUID!`): ID of the Datadog integration
    * `title` (`String!`): Title of the incident
    """

    link_datadog_incident_for_alert = sgqlc.types.Field(
        LinkDatadogIncidentForAlert,
        graphql_name="linkDatadogIncidentForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "dd_incident_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="ddIncidentUrl", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Link Datadog Incident for Alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `dd_incident_url` (`String!`): Full Datadog incident URL (any
      site/region). Requires incident_read scope to resolve the
      incident UUID.
    * `integration_id` (`UUID!`): ID of the Datadog integration
    """

    unlink_datadog_incident_for_alert = sgqlc.types.Field(
        "UnlinkDatadogIncidentForAlert",
        graphql_name="unlinkDatadogIncidentForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "dd_incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="ddIncidentId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Unlink Datadog Incident for Alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `dd_incident_id` (`String!`): Datadog internal incident id
    * `integration_id` (`UUID!`): ID of the Datadog integration
    """

    create_or_update_table_monitor = sgqlc.types.Field(
        CreateOrUpdateTableMonitor,
        graphql_name="createOrUpdateTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TableMonitorAlertConditionInput)),
                        graphql_name="alertConditions",
                        default=None,
                    ),
                ),
                (
                    "asset_selection",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AssetSelectionInput),
                        graphql_name="assetSelection",
                        default=None,
                    ),
                ),
                (
                    "audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="audiences",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_restrictions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainRestrictions",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update a Table monitor

    Arguments:

    * `alert_conditions` (`[TableMonitorAlertConditionInput!]`): Alert
      conditions for the table monitor
    * `asset_selection` (`AssetSelectionInput!`)None
    * `audiences` (`[String!]`): The monitor notification audiences
    * `data_quality_dimension` (`String`): Data quality dimension of
      the monitor.
    * `description` (`String!`): Description of rule
    * `domain_restrictions` (`[UUID!]`): The domains to restrict to
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the YAML and queries. (default: `false`)
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `tags` (`[TagKeyValuePairInput!]`): The monitor tags.
    * `uuid` (`UUID`): UUID of the table monitor, to update existing
      monito
    * `warehouse_uuid` (`UUID!`): Warehouse UUID
    """

    pause_table_monitor = sgqlc.types.Field(
        "PauseTableMonitor",
        graphql_name="pauseTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "pause",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="pause", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable a Table monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): UUID of the table monitor to
      pause/unpause
    * `pause` (`Boolean!`): Pause state of the monitor
    """

    delete_table_monitor = sgqlc.types.Field(
        DeleteTableMonitor,
        graphql_name="deleteTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete a Table monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): UUID of the table monitor to delete
    """

    create_single_table_monitoring_notification = sgqlc.types.Field(
        CreateSingleTableMonitoringNotification,
        graphql_name="createSingleTableMonitoringNotification",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "table_monitor_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="tableMonitorUuid", default=None),
                ),
                ("usage_rule_id", sgqlc.types.Arg(Int, graphql_name="usageRuleId", default=None)),
            )
        ),
    )
    """(experimental) Record a single-table monitoring enablement event

    Arguments:

    * `mcon` (`String!`): MCON of the table for which monitoring was
      enabled
    * `table_monitor_uuid` (`UUID`): UUID of the TableMonitor that
      enabled monitoring for this table. Provide either this or
      usageRuleId, but not both.
    * `usage_rule_id` (`Int`): ID of the MonitoredTableRule that
      enabled monitoring for this table. Provide either this or
      tableMonitorUuid, but not both.
    """

    update_monitor_tags = sgqlc.types.Field(
        "UpdateMonitorTags",
        graphql_name="updateMonitorTags",
        args=sgqlc.types.ArgDict(
            (
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set whether to group dbt snapshot failures with the
    same error message into the same incident

    Arguments:

    * `monitor_type` (`String`): DEPRECATED: field is ignored
    * `monitor_uuid` (`UUID!`): UUID of the metric monitor or custom
      rule
    * `tags` (`[TagKeyValuePairInput]!`): Tags to insert on the
      monitor
    """

    bulk_add_monitor_tags = sgqlc.types.Field(
        BulkAddMonitorTags,
        graphql_name="bulkAddMonitorTags",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Bulk add monitor tags.

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): UUIDs of the metric monitor or
      custom rule
    * `tags` (`[TagKeyValuePairInput]!`): Tags to insert on the
      monitor
    """

    delete_monitor_tag = sgqlc.types.Field(
        DeleteMonitorTag,
        graphql_name="deleteMonitorTag",
        args=sgqlc.types.ArgDict(
            (
                (
                    "tag_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="tagId", default=None),
                ),
            )
        ),
    )
    """(experimental) Delete unused monitor tag

    Arguments:

    * `tag_id` (`UUID!`): UUID of the tag to delete
    """

    update_monitor_data_quality_dimension = sgqlc.types.Field(
        "UpdateMonitorDataQualityDimension",
        graphql_name="updateMonitorDataQualityDimension",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "monitor_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="monitorType", default=None
                    ),
                ),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Update data quality dimension on a monitor.

    Arguments:

    * `data_quality_dimension` (`String`): Data quality dimension to
      assign to the monitor.If not set, we'll clear the data quality
      dimension on the monitor.
    * `monitor_type` (`String!`): Type of monitor.
    * `monitor_uuid` (`UUID!`): UUID of the metric monitor or custom
      rule.
    """

    bulk_add_monitor_data_quality_dimension = sgqlc.types.Field(
        BulkAddMonitorDataQualityDimension,
        graphql_name="bulkAddMonitorDataQualityDimension",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Bulk add monitor data quality dimension.

    Arguments:

    * `data_quality_dimension` (`String`): Data quality dimension to
      assign to monitors
    * `monitor_uuids` (`[UUID!]!`): UUIDs of the metric monitor or
      custom rule
    """

    create_or_update_tag = sgqlc.types.Field(
        CreateOrUpdateTagMutation,
        graphql_name="createOrUpdateTag",
        args=sgqlc.types.ArgDict(
            (
                ("tag_name", sgqlc.types.Arg(String, graphql_name="tagName", default=None)),
                ("tag_type", sgqlc.types.Arg(TagType, graphql_name="tagType", default=None)),
                ("tag_uuid", sgqlc.types.Arg(UUID, graphql_name="tagUuid", default=None)),
                ("tag_value", sgqlc.types.Arg(String, graphql_name="tagValue", default=None)),
            )
        ),
    )
    """(experimental) Create or update a tag.

    Arguments:

    * `tag_name` (`String`): Tag name. Required when creating a new
      tag.
    * `tag_type` (`TagType`): Tag type. Required when creating a new
      tag, and tag_type can't be changed once created.
    * `tag_uuid` (`UUID`): UUID of tag for update.
    * `tag_value` (`String`): Tag value.
    """

    create_or_update_tag_assignments = sgqlc.types.Field(
        CreateOrUpdateTagAssignmentsMutation,
        graphql_name="createOrUpdateTagAssignments",
        args=sgqlc.types.ArgDict(
            (
                (
                    "object_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="objectIds",
                        default=None,
                    ),
                ),
                (
                    "object_type",
                    sgqlc.types.Arg(
                        TagAssignmentObjectType, graphql_name="objectType", default=None
                    ),
                ),
                (
                    "tag_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TagType), graphql_name="tagType", default=None
                    ),
                ),
                (
                    "tag_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="tagUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update tags assignments for a list of
    objects with the same type.

    Arguments:

    * `object_ids` (`[String]!`): Object ids.
    * `object_type` (`TagAssignmentObjectType`): Object type.
    * `tag_type` (`TagType!`): Tag Type.
    * `tag_uuids` (`[UUID]!`): UUIDs of tags to assign to the objects.
    """

    create_or_update_data_operations_dashboard = sgqlc.types.Field(
        CreateOrUpdateDataOperationsDashboardMutation,
        graphql_name="createOrUpdateDataOperationsDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "criteria",
                    sgqlc.types.Arg(DODCriteriaInput, graphql_name="criteria", default=None),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """(experimental) Create or update data operations dashboard.

    Arguments:

    * `criteria` (`DODCriteriaInput`): Criteria for the dashboard.
    * `description` (`String`): Description of the Data Operations
      Dashboard
    * `name` (`String`): Data Operations Dashboard name
    * `uuid` (`UUID`): UUID of data operations dashboard to update
    """

    delete_data_operations_dashboard = sgqlc.types.Field(
        DeleteDataOperationsDashboardMutation,
        graphql_name="deleteDataOperationsDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_operations_dashboard_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="dataOperationsDashboardUuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Delete a data operations dashboard.

    Arguments:

    * `data_operations_dashboard_uuid` (`UUID`): UUID of the data
      operations dashboard to delete.
    """

    create_or_update_validation = sgqlc.types.Field(
        CreateOrUpdateValidation,
        graphql_name="createOrUpdateValidation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(FilterGroupInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
            )
        ),
    )
    """Create or update a validation

    Arguments:

    * `alert_condition` (`FilterGroupInput!`)None
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `data_source` (`DataSourceUnionInput!`)None
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `dw_id` (`UUID!`): Warehouse UUID
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of the
      validation
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timeout` (`Int`): Timeout for the SQL query
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    """

    caas_link_collection_resources = sgqlc.types.Field(
        CaasLinkCollectionResources,
        graphql_name="caasLinkCollectionResources",
        args=sgqlc.types.ArgDict(
            (
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Links a pre-provisioned node and data-store to the specified DC.
    Only non-active DCs with template_variant=aether are supported.

    Arguments:

    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    caas_update_collection_node_parameters = sgqlc.types.Field(
        CaasUpdateCollectionNodeParameters,
        graphql_name="caasUpdateCollectionNodeParameters",
        args=sgqlc.types.ArgDict(
            (
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
                (
                    "updates",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GenericScalar), graphql_name="updates", default=None
                    ),
                ),
            )
        ),
    )
    """Updates the parameters for the collection node associated to the
    specified DC

    Arguments:

    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    * `updates` (`GenericScalar!`): Dictionary containing the values
      to update
    """

    caas_update_collection_node_env = sgqlc.types.Field(
        CaasUpdateCollectionNodeEnv,
        graphql_name="caasUpdateCollectionNodeEnv",
        args=sgqlc.types.ArgDict(
            (
                ("replace", sgqlc.types.Arg(Boolean, graphql_name="replace", default=False)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
                (
                    "updates",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GenericScalar), graphql_name="updates", default=None
                    ),
                ),
            )
        ),
    )
    """Updates the environment variables for the collection node
    associated to the specified DC

    Arguments:

    * `replace` (`Boolean`): If True, the current environment
      variables will be replaced by the new ones (default: `false`)
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    * `updates` (`GenericScalar!`): Dictionary containing the values
      to update
    """

    caas_update_collection_storage_parameters = sgqlc.types.Field(
        CaasUpdateCollectionStorageParameters,
        graphql_name="caasUpdateCollectionStorageParameters",
        args=sgqlc.types.ArgDict(
            (
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
                (
                    "updates",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GenericScalar), graphql_name="updates", default=None
                    ),
                ),
            )
        ),
    )
    """Updates the parameters for the collection storage associated to
    the specified DC

    Arguments:

    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    * `updates` (`GenericScalar!`): JSON string with a dictionary
      containing the values to update
    """

    caas_update_collection_storage_version = sgqlc.types.Field(
        CaasUpdateCollectionStorageVersion,
        graphql_name="caasUpdateCollectionStorageVersion",
        args=sgqlc.types.ArgDict(
            (
                (
                    "service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="serviceUuid", default=None
                    ),
                ),
                (
                    "template_version",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="templateVersion", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Updates the collection storage template version
    associated to a DC.

    Arguments:

    * `service_uuid` (`UUID!`): Platform Service UUID. To disambiguate
      accounts with multiple services
    * `template_version` (`Int!`): Template version to upgrade to
    """

    caas_update_collection_node_version = sgqlc.types.Field(
        CaasUpdateCollectionNodeVersion,
        graphql_name="caasUpdateCollectionNodeVersion",
        args=sgqlc.types.ArgDict(
            (
                ("code_version", sgqlc.types.Arg(String, graphql_name="codeVersion", default=None)),
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
                (
                    "template_version",
                    sgqlc.types.Arg(String, graphql_name="templateVersion", default=None),
                ),
            )
        ),
    )
    """Updates the collection node associated to the specified DC to the
    specified version.If no version is provided, the node is upgraded
    to latest version.

    Arguments:

    * `code_version` (`String`): Optional version to upgrade to, if
      not specified latest GA version is used
    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    * `template_version` (`String`): Optional template version to
      upgrade to, if not specified and code is not specified either,
      then the template is also updated to latest GA
    """

    trigger_platform_migration = sgqlc.types.Field(
        "TriggerPlatformMigration",
        graphql_name="triggerPlatformMigration",
        args=sgqlc.types.ArgDict(
            (
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=True)),
                ("rollback", sgqlc.types.Arg(Boolean, graphql_name="rollback", default=True)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Triggers the platform migration for a given DC in background,
    dryRun can be used to run validations without performing the
    migration.

    Arguments:

    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `dry_run` (`Boolean`): Runs only validations without performing
      the migration when True (default: `true`)
    * `rollback` (`Boolean`): Whether to rollback the migration if
      validation before migration fails. This will delete the DC and
      CaaS node created to perform the migration. (default: `true`)
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    trigger_platform_migration_test = sgqlc.types.Field(
        "TriggerPlatformMigrationTest",
        graphql_name="triggerPlatformMigrationTest",
        args=sgqlc.types.ArgDict(
            (
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Triggers a platform migration test for a given DC in background,
    use getPlatformMigrationTestStatus to get results.

    Arguments:

    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    trigger_migration_test = sgqlc.types.Field(
        "TriggerMigrationTest",
        graphql_name="triggerMigrationTest",
        args=sgqlc.types.ArgDict(
            (
                (
                    "overrides",
                    sgqlc.types.Arg(GenericScalar, graphql_name="overrides", default=None),
                ),
                (
                    "resource_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="resourceUuids", default=None
                    ),
                ),
                (
                    "run_all_validations",
                    sgqlc.types.Arg(Boolean, graphql_name="runAllValidations", default=False),
                ),
                (
                    "source_dc_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="sourceDcUuid", default=None),
                ),
                (
                    "source_service_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="sourceServiceUuid", default=None),
                ),
                (
                    "target_dc_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="targetDcUuid", default=None),
                ),
                (
                    "target_service_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="targetServiceUuid", default=None),
                ),
            )
        ),
    )
    """Triggers the DC migration test operation that checks if all
    connections in DC can be migrated to target_dc. Validations are
    executed in background, you can check the progress using
    getMigrationTestStatus.

    Arguments:

    * `overrides` (`GenericScalar`): Dictionary containing properties
      to override per connection. The key must be the connection UUID
      and the value a dictionary including new values for the
      connection properties, like 'host'.
    * `resource_uuids` (`[UUID]`): List of resource UUIDs to test for
      migration. By default all resources will be tested.
    * `run_all_validations` (`Boolean`): If True, all validations will
      be run, otherwise only the ones marked as prerequisite will be
      executed. (default: `false`)
    * `source_dc_uuid` (`UUID`): [Deprecated] Use sourceServiceUuid
      instead
    * `source_service_uuid` (`UUID`): Source Platform Service UUID.
    * `target_dc_uuid` (`UUID`): [Deprecated] Use targetServiceUuid
      instead
    * `target_service_uuid` (`UUID`): Target Platform Service UUID.
    """

    add_platform_service = sgqlc.types.Field(
        AddPlatformService,
        graphql_name="addPlatformService",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assign_data_store",
                    sgqlc.types.Arg(Boolean, graphql_name="assignDataStore", default=True),
                ),
                (
                    "settings_source_service_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="settingsSourceServiceUuid", default=None),
                ),
            )
        ),
    )
    """Adds a new platform service to the account, restricted operation.

    Arguments:

    * `assign_data_store` (`Boolean`): If True, a data store is
      assigned to the service (default: `true`)
    * `settings_source_service_uuid` (`UUID`): Optional platform
      service to use as the source for settings (concurrency, memory
      and env vars). If not provided, default settings will be used.
    """

    restore_collection_storage = sgqlc.types.Field(
        "RestoreCollectionStorage",
        graphql_name="restoreCollectionStorage",
        args=sgqlc.types.ArgDict(
            (("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),)
        ),
    )
    """(experimental) Associates a new built-in collection storage to the
    specified service if no other storage or agent is associated.

    Arguments:

    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    connect_platform_service_to_legacy_bucket = sgqlc.types.Field(
        ConnectPlatformServiceToLegacyBucket,
        graphql_name="connectPlatformServiceToLegacyBucket",
        args=sgqlc.types.ArgDict(
            (
                (
                    "source_service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="sourceServiceUuid", default=None
                    ),
                ),
                (
                    "target_service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="targetServiceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Connects a platform service to the bucket used by a
    legacy DC in the same account.

    Arguments:

    * `source_service_uuid` (`UUID!`): Source Platform Service UUID.
    * `target_service_uuid` (`UUID!`): Target Platform Service UUID.
    """

    connect_platform_service_to_existing_bucket = sgqlc.types.Field(
        ConnectPlatformServiceToExistingBucket,
        graphql_name="connectPlatformServiceToExistingBucket",
        args=sgqlc.types.ArgDict(
            (
                (
                    "bucket_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="bucketName", default=None
                    ),
                ),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """(experimental) Connects a platform service to an existing bucket,
    creating a new data store. The bucket must be updated to allow
    access to the execution roles used by the node. Use
    getPlatformServiceExecutionRoles to get the list of roles to
    enable.

    Arguments:

    * `bucket_name` (`String!`): Name of the bucket to connect to.
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    connect_platform_to_existing_agent = sgqlc.types.Field(
        ConnectPlatformServiceToExistingAgent,
        graphql_name="connectPlatformToExistingAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "source_service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="sourceServiceUuid", default=None
                    ),
                ),
                (
                    "target_service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="targetServiceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Connects a platform service to an existing agent,
    linked to another service in the same account.

    Arguments:

    * `source_service_uuid` (`UUID!`): Source Platform Service UUID.
    * `target_service_uuid` (`UUID!`): Target Platform Service UUID.
    """

    caas_update_collection_storage_link = sgqlc.types.Field(
        CaasUpdateCollectionStorageLink,
        graphql_name="caasUpdateCollectionStorageLink",
        args=sgqlc.types.ArgDict(
            (("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),)
        ),
    )
    """(experimental) If there's an agent associated to the service, it
    makes sure the link to the CaaS storage is deleted.

    Arguments:

    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    caas_update_collection_storage_encryption = sgqlc.types.Field(
        CaasUpdateCollectionStorageEncryption,
        graphql_name="caasUpdateCollectionStorageEncryption",
        args=sgqlc.types.ArgDict(
            (
                (
                    "encryption_type",
                    sgqlc.types.Arg(
                        StorageEncryptionType,
                        graphql_name="encryptionType",
                        default="AMAZON_S3_SSE",
                    ),
                ),
                (
                    "service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="serviceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Sets the collection storage encryption

    Arguments:

    * `encryption_type` (`StorageEncryptionType`): Type of storage
      encryption (default: 'AMAZON_S3_SSE') (default:
      `"AMAZON_S3_SSE"`)
    * `service_uuid` (`UUID!`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    refresh_entitlements = sgqlc.types.Field(
        "RefreshEntitlements", graphql_name="refreshEntitlements"
    )

    run_table_monitor_validation = sgqlc.types.Field(
        "RunTableMonitorValidation",
        graphql_name="runTableMonitorValidation",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """Start a monitor validation process for a table

    Arguments:

    * `mcon` (`String`): MC resource unique identifier
    """

    test_updated_credentials_v2 = sgqlc.types.Field(
        "TestUpdatedCredentialsV2Mutation",
        graphql_name="testUpdatedCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                (
                    "temp_credentials_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="tempCredentialsKey",
                        default=None,
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test the updated credentials of an existing connection.

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `connection_type` (`String!`): The type of the existing
      connection to test.
    * `temp_credentials_key` (`String!`): The temporary credentials
      key to use to retrieve new credentials.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    update_credentials_v2 = sgqlc.types.Field(
        "UpdateCredentialsV2Mutation",
        graphql_name="updateCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "temp_credentials_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="tempCredentialsKey",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Save the updated credentials for an existing connection.

    Arguments:

    * `connection_id` (`UUID!`): The connection uuid of the connection
      to update.
    * `temp_credentials_key` (`String!`): The temporary credentials
      key to use to retrieve new credentials.
    """

    update_self_hosted_credentials_v2 = sgqlc.types.Field(
        "UpdateSelfHostedCredentialsV2Mutation",
        graphql_name="updateSelfHostedCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SelfHostedUpdateCredentialsConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Update self-hosted credentials for existing
    connection

    Arguments:

    * `changes` (`SelfHostedUpdateCredentialsConnectionDetails!`):
      Updated connection parameters for the connection with self-
      hosted credentials.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_dbt_cloud_credentials_v2_mutation = sgqlc.types.Field(
        "UpdateDbtCloudCredentialsV2Mutation",
        graphql_name="updateDbtCloudCredentialsV2Mutation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DbtCloudUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing dbt cloud connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`DbtCloudUpdateConnectionDetails!`): Updated dbt
      Cloud connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_transactional_db_credentials_v2 = sgqlc.types.Field(
        "UpdateTransactionalDbCredentialsV2Mutation",
        graphql_name="updateTransactionalDbCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TransactionalDbUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Transactional DB connection.
    Note: This mutation only uploads credentials and returns a
    temporary key. To complete the update:  Call
    testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`TransactionalDbUpdateConnectionDetails!`): Updated
      Transactional DB connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_big_query_credentials_v2 = sgqlc.types.Field(
        "UpdateBigQueryCredentialsV2Mutation",
        graphql_name="updateBigQueryCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(BigQueryUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Big Query connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`BigQueryUpdateConnectionDetails!`): Updated Big
      Query connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_tableau_credentials_v2 = sgqlc.types.Field(
        "UpdateTableauCredentialsV2Mutation",
        graphql_name="updateTableauCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TableauUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Tableau connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`TableauUpdateConnectionDetails!`): Updated Tableau
      connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_looker_credentials_v2 = sgqlc.types.Field(
        "UpdateLookerCredentialsV2Mutation",
        graphql_name="updateLookerCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LookerUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Looker connection.  Note: This
    mutation only uploads credentials and returns a temporary key. To
    complete the update:  Call testUpdatedCredentialsV2 with the
    returned key as tempCredentialsKey and the same connectionId to
    validate the credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`LookerUpdateConnectionDetails!`): Updated Looker
      connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_looker_git_auth_credentials_v2 = sgqlc.types.Field(
        "UpdateLookerGitAuthCredentialsV2Mutation",
        graphql_name="updateLookerGitAuthCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LookerGitAuthUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Updates the Git authentication details, supports
    HTTPS or SSH protocol.

    Arguments:

    * `changes` (`LookerGitAuthUpdateConnectionDetails!`): Updated
      Looker connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_power_bi_credentials_v2 = sgqlc.types.Field(
        "UpdatePowerBiCredentialsV2Mutation",
        graphql_name="updatePowerBiCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(PowerBiUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing PowerBi connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`PowerBiUpdateConnectionDetails!`): Updated PowerBi
      connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_snowflake_credentials_v2 = sgqlc.types.Field(
        "UpdateSnowflakeCredentialsV2Mutation",
        graphql_name="updateSnowflakeCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SnowflakeUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Snowflake connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`SnowflakeUpdateConnectionDetails!`): Updated
      Snowflake connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_redshift_credentials_v2 = sgqlc.types.Field(
        "UpdateRedshiftCredentialsV2Mutation",
        graphql_name="updateRedshiftCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(RedshiftUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Redshift connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`RedshiftUpdateConnectionDetails!`): Updated Redshift
      connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_databricks_metastore_sql_warehouse_credentials_v2 = sgqlc.types.Field(
        "UpdateDatabricksMetastoreSQLWarehouseCredentialsV2Mutation",
        graphql_name="updateDatabricksMetastoreSqlWarehouseCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatabricksSqlWarehouseUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Databricks Metastore SQL
    Warehouse connection.  Note: This mutation only uploads
    credentials and returns a temporary key. To complete the update:
    Call testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`DatabricksSqlWarehouseUpdateConnectionDetails!`):
      Updated Databricks Metastore SQL Warehouse connection
      parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_databricks_sql_warehouse_credentials_v2 = sgqlc.types.Field(
        "UpdateDatabricksSQLWarehouseCredentialsV2Mutation",
        graphql_name="updateDatabricksSqlWarehouseCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatabricksSqlWarehouseUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Databricks SQL Warehouse
    connection.  Note: This mutation only uploads credentials and
    returns a temporary key. To complete the update:  Call
    testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`DatabricksSqlWarehouseUpdateConnectionDetails!`):
      Updated Databricks SQL Warehouse connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_azure_data_factory_credentials_v2 = sgqlc.types.Field(
        "UpdateAzureDataFactoryCredentialsV2Mutation",
        graphql_name="updateAzureDataFactoryCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AzureDataFactoryUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Updates Azure Data Factory credentials for an
    existing connection

    Arguments:

    * `changes` (`AzureDataFactoryUpdateConnectionDetails!`): Updated
      Azure Data Factory connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    update_pinecone_credentials_v2 = sgqlc.types.Field(
        "UpdatePineconeCredentialsV2Mutation",
        graphql_name="updatePineconeCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(PineconeUpdateConnectionDetails),
                        graphql_name="changes",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Update credentials for an existing Pinecone connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.

    Arguments:

    * `changes` (`PineconeUpdateConnectionDetails!`): Updated Pinecone
      connection parameters.
    * `connection_id` (`UUID!`): ID for connection to update.
    """

    create_or_update_data_explorer_dashboard = sgqlc.types.Field(
        CreateOrUpdateDataExplorerDashboardMutation,
        graphql_name="createOrUpdateDataExplorerDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_explorer_dashboard",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataExplorerDashboardInputType),
                        graphql_name="dataExplorerDashboard",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `data_explorer_dashboard`
      (`DataExplorerDashboardInputType!`)None
    """

    delete_data_explorer_dashboard = sgqlc.types.Field(
        DeleteDataExplorerDashboardMutation,
        graphql_name="deleteDataExplorerDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `uuid` (`UUID!`): UUID of dashboard to be deleted
    """

    create_or_update_data_explorer_comparison_dashboard = sgqlc.types.Field(
        CreateOrUpdateDataExplorerComparisonDashboardMutation,
        graphql_name="createOrUpdateDataExplorerComparisonDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_explorer_comparison_dashboard",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataExplorerComparisonDashboardInputType),
                        graphql_name="dataExplorerComparisonDashboard",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `data_explorer_comparison_dashboard`
      (`DataExplorerComparisonDashboardInputType!`)None
    """

    delete_data_explorer_comparison_dashboard = sgqlc.types.Field(
        DeleteDataExplorerComparisonDashboardMutation,
        graphql_name="deleteDataExplorerComparisonDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `uuid` (`UUID!`): UUID of comparison dashboard to be deleted
    """

    create_webex_integration = sgqlc.types.Field(
        CreateWebexIntegration,
        graphql_name="createWebexIntegration",
        args=sgqlc.types.ArgDict(
            (
                ("bot_token", sgqlc.types.Arg(String, graphql_name="botToken", default=None)),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
            )
        ),
    )
    """Create a Webex integration

    Arguments:

    * `bot_token` (`String`): The bot token for authentication; if not
      provided, the previous value will be used
    * `integration_name` (`String!`): A short name to identify the
      integration
    """

    update_webex_integration = sgqlc.types.Field(
        "UpdateWebexIntegration",
        graphql_name="updateWebexIntegration",
        args=sgqlc.types.ArgDict(
            (
                ("bot_token", sgqlc.types.Arg(String, graphql_name="botToken", default=None)),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
            )
        ),
    )
    """Update a Webex integration

    Arguments:

    * `bot_token` (`String`): The bot token for authentication; if not
      provided, the previous value will be used
    * `integration_id` (`UUID!`): The integration ID
    * `integration_name` (`String!`): A short name to identify the
      integration
    """

    delete_webex_integration = sgqlc.types.Field(
        DeleteWebexIntegration,
        graphql_name="deleteWebexIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a Webex integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    update_monitored_table_rule_list = sgqlc.types.Field(
        sgqlc.types.list_of(MonitoredTableRuleObject),
        graphql_name="updateMonitoredTableRuleList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dataset", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "project",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="project", default=None
                    ),
                ),
                (
                    "rules",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(MonitoredTableRuleInput)),
                        graphql_name="rules",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Deprecated - use async version

    Arguments:

    * `dataset` (`String!`): Rules apply to tables in this
      dataset/schema
    * `dw_id` (`UUID!`): Rules apply to tables in this warehouse
    * `project` (`String!`): Rules apply to tables in this
      project/database
    * `rules` (`[MonitoredTableRuleInput]!`): The complete list of
      rules for deciding which tables are monitored
    """

    update_monitored_table_rule_list_async = sgqlc.types.Field(
        MonitoredTableRuleListUpdateOutput,
        graphql_name="updateMonitoredTableRuleListAsync",
        args=sgqlc.types.ArgDict(
            (
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                (
                    "rules",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(MonitoredTableRuleInput)),
                        graphql_name="rules",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Updates the list of rules for deciding and applies them
    asynchronously.

    Arguments:

    * `dataset` (`String`): Rules apply to tables in this
      dataset/schema
    * `dw_id` (`UUID!`): Rules apply to tables in this warehouse
    * `project` (`String`): Rules apply to tables in this
      project/database
    * `rules` (`[MonitoredTableRuleInput]!`): The complete list of
      rules for deciding which tables are monitored
    """

    add_monitored_table_rule_async = sgqlc.types.Field(
        MonitoredTableRuleListUpdateOutput,
        graphql_name="addMonitoredTableRuleAsync",
        args=sgqlc.types.ArgDict(
            (
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "priority_mcon",
                    sgqlc.types.Arg(String, graphql_name="priorityMcon", default=None),
                ),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                (
                    "rule",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MonitoredTableRuleInput),
                        graphql_name="rule",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(general availability) Adds a new monitoring rule in the requested
    scope.

    Arguments:

    * `dataset` (`String`): Rules apply to tables in this
      dataset/schema
    * `dw_id` (`UUID!`): Rules apply to tables in this warehouse
    * `priority_mcon` (`String`): Apply rules so that this MCON is
      enabled first
    * `project` (`String`): Rules apply to tables in this
      project/database
    * `rule` (`MonitoredTableRuleInput!`): New monitoring rule
    """

    toggle_performance_dashboard_for_domain_restricted_users = sgqlc.types.Field(
        "TogglePerformanceDashboardForDomainRestrictedUsers",
        graphql_name="togglePerformanceDashboardForDomainRestrictedUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enabled", default=None
                    ),
                ),
            )
        ),
    )
    """Sets the toggle for enabling performance dashboard for domain
    restricted users

    Arguments:

    * `enabled` (`Boolean!`): Enable performance dashboard for domain
      restricted user
    """

    create_or_update_agent = sgqlc.types.Field(
        CreateOrUpdateAgent,
        graphql_name="createOrUpdateAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "additional_info",
                    sgqlc.types.Arg(JSONString, graphql_name="additionalInfo", default=None),
                ),
                ("agent_id", sgqlc.types.Arg(UUID, graphql_name="agentId", default=None)),
                (
                    "agent_type",
                    sgqlc.types.Arg(AgentTypeEnum, graphql_name="agentType", default=None),
                ),
                ("auth_type", sgqlc.types.Arg(AuthTypeEnum, graphql_name="authType", default=None)),
                (
                    "credentials",
                    sgqlc.types.Arg(JSONString, graphql_name="credentials", default=None),
                ),
                (
                    "data_collector_id",
                    sgqlc.types.Arg(UUID, graphql_name="dataCollectorId", default=None),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                ("endpoint", sgqlc.types.Arg(String, graphql_name="endpoint", default=None)),
                (
                    "friendly_name",
                    sgqlc.types.Arg(String, graphql_name="friendlyName", default=None),
                ),
                ("image_build", sgqlc.types.Arg(String, graphql_name="imageBuild", default=None)),
                (
                    "image_version",
                    sgqlc.types.Arg(String, graphql_name="imageVersion", default=None),
                ),
                (
                    "platform",
                    sgqlc.types.Arg(PlatformTypeEnum, graphql_name="platform", default=None),
                ),
                (
                    "storage_type",
                    sgqlc.types.Arg(StorageTypeEnum, graphql_name="storageType", default=None),
                ),
                ("upgradeable", sgqlc.types.Arg(Boolean, graphql_name="upgradeable", default=None)),
                ("wrapper_type", sgqlc.types.Arg(String, graphql_name="wrapperType", default=None)),
                (
                    "wrapper_version",
                    sgqlc.types.Arg(String, graphql_name="wrapperVersion", default=None),
                ),
            )
        ),
    )
    """Create or Update a Monte Carlo Agent

    Arguments:

    * `additional_info` (`JSONString`): Additional information for the
      agent, for now only `account_name` is supported and used by
      Snowflake agents for the endpoint value.
    * `agent_id` (`UUID`): UUID of Agent to update.
    * `agent_type` (`AgentTypeEnum`): The type of Agent being
      deployed.
    * `auth_type` (`AuthTypeEnum`): The type of authorization
      provided.
    * `credentials` (`JSONString`): JSON of credentials for Agent.
    * `data_collector_id` (`UUID`): The UUID of the Data Collector to
      associate the agent with.
    * `dry_run` (`Boolean`): Dry run? (default: `false`)
    * `endpoint` (`String`): Bucket name, IP address or URL of the
      agent.
    * `friendly_name` (`String`): Friendly name for the agent, for now
      used only for connections automatically created when registering
      Snowflake agents.
    * `image_build` (`String`): Build number of agent image. Ignored
      if agent type is DATA_STORE_AGENT.
    * `image_version` (`String`): The image version of the Agent. Null
      if agent type is data_store.
    * `platform` (`PlatformTypeEnum`): The cloud platform the agent is
      deployed on.
    * `storage_type` (`StorageTypeEnum`): The storage type of the
      Agent.
    * `upgradeable` (`Boolean`): Boolean if the agent is remote
      upgradeable.
    * `wrapper_type` (`String`): The wrapper type of the Agent.
    * `wrapper_version` (`String`): The wrapper version of the Agent.
    """

    delete_agent = sgqlc.types.Field(
        DeleteAgent,
        graphql_name="deleteAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a Monte Carlo Agent

    Arguments:

    * `agent_id` (`UUID!`): UUID of Agent to delete
    """

    upgrade_agent = sgqlc.types.Field(
        "UpgradeAgent",
        graphql_name="upgradeAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("image", sgqlc.types.Arg(String, graphql_name="image", default=None)),
                (
                    "parameters",
                    sgqlc.types.Arg(GenericScalar, graphql_name="parameters", default=None),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("trace_id", sgqlc.types.Arg(String, graphql_name="traceId", default=None)),
            )
        ),
    )
    """Upgrades a Monte Carlo Agent to a given version

    Arguments:

    * `agent_id` (`UUID!`): The UUID of the Agent to upgrade.
    * `image` (`String`): Image to upgrade the agent to (upgrades to
      the latest image by default).
    * `parameters` (`GenericScalar`): New values for template
      parameters, for example: MemorySize=1024
    * `timeout` (`Int`): Time to wait for the upgrade to complete
    * `trace_id` (`String`): Trace ID for the request.
    """

    update_agent_parameters = sgqlc.types.Field(
        "UpdateAgentParameters",
        graphql_name="updateAgentParameters",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "parameters",
                    sgqlc.types.Arg(GenericScalar, graphql_name="parameters", default=None),
                ),
                ("trace_id", sgqlc.types.Arg(String, graphql_name="traceId", default=None)),
            )
        ),
    )
    """Updates agent parameters like MemorySize or ConcurrentExecutions.

    Arguments:

    * `agent_id` (`UUID!`): The UUID of the Agent to update
      parameters.
    * `parameters` (`GenericScalar`): New values for template
      parameters, for example: MemorySize=1024
    * `trace_id` (`String`): Trace ID for the request.
    """

    restart_agent = sgqlc.types.Field(
        "RestartAgent",
        graphql_name="restartAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("trace_id", sgqlc.types.Arg(String, graphql_name="traceId", default=None)),
            )
        ),
    )
    """Restarts an agent, supported only for Azure agents.

    Arguments:

    * `agent_id` (`UUID!`): The UUID of the Agent to restart,
      supported only for Azure agents.
    * `trace_id` (`String`): Trace ID for the request.
    """

    cleanup_azure_agent_tasks = sgqlc.types.Field(
        AzureAgentCleanupTasks,
        graphql_name="cleanupAzureAgentTasks",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "created_time_from",
                    sgqlc.types.Arg(DateTime, graphql_name="createdTimeFrom", default=None),
                ),
                (
                    "created_time_to",
                    sgqlc.types.Arg(DateTime, graphql_name="createdTimeTo", default=None),
                ),
                (
                    "include_pending",
                    sgqlc.types.Arg(Boolean, graphql_name="includePending", default=None),
                ),
            )
        ),
    )
    """Cleanup Durable Functions tasks for an Azure Agent

    Arguments:

    * `agent_id` (`UUID!`): The UUID of the Azure Agent to cleanup
      Durable Functions tasks.
    * `created_time_from` (`DateTime`): Optional start time, defaults
      to 10 years ago
    * `created_time_to` (`DateTime`): Optional end time, defaults to
      10 minutes ago
    * `include_pending` (`Boolean`): Include pending tasks in the
      cleanup, defaults to false.
    """

    migrate_connection_to_snowflake_agent = sgqlc.types.Field(
        MigrateConnectionToSnowflakeAgent,
        graphql_name="migrateConnectionToSnowflakeAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Migrate an existing connection to a Snowflake Agent

    Arguments:

    * `agent_id` (`UUID!`): UUID of Agent to migrate to.
    * `connection_id` (`UUID!`): UUID of Connection to migrate.
    """

    migrate_connection_from_snowflake_agent = sgqlc.types.Field(
        MigrateConnectionFromSnowflakeAgent,
        graphql_name="migrateConnectionFromSnowflakeAgent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SnowflakeConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "service_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="serviceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Migrates a Snowflake Agent connection to another
    platform service

    Arguments:

    * `connection_details` (`SnowflakeConnectionDetails!`): Connection
      parameters.
    * `connection_id` (`UUID!`): UUID of Connection to migrate.
    * `service_uuid` (`UUID!`): UUID of DC to migrate to.
    """

    create_tableau_asset_warning = sgqlc.types.Field(
        CreateTableauAssetWarning,
        graphql_name="createTableauAssetWarning",
        args=sgqlc.types.ArgDict(
            (
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                (
                    "bi_container_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="biContainerId", default=None
                    ),
                ),
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                (
                    "message",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="message", default=None
                    ),
                ),
                (
                    "tableau_asset_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tableauAssetType", default=None
                    ),
                ),
                (
                    "tableau_luid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tableauLuid", default=None
                    ),
                ),
            )
        ),
    )
    """Create tableau asset warning

    Arguments:

    * `alert_id` (`UUID`): UUID of the alert for which this warning is
      being created.
    * `bi_container_id` (`UUID!`): UUID of the Tableau container for
      which this warning is being created.
    * `incident_id` (`UUID`): UUID of the incident for which this
      warning is being created. Deprecated, use alertId instead
    * `message` (`String!`): The message of the warning
    * `tableau_asset_type` (`String!`): The type of the Tableau asset.
      This is a string defined by Tableau. Eg: datasource
    * `tableau_luid` (`String!`): The Tableau LUID of the tableau
      asset for which the warning is being created.
    """

    update_tableau_asset_warning = sgqlc.types.Field(
        "UpdateTableauAssetWarning",
        graphql_name="updateTableauAssetWarning",
        args=sgqlc.types.ArgDict(
            (
                (
                    "bi_container_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="biContainerId", default=None
                    ),
                ),
                (
                    "message",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="message", default=None
                    ),
                ),
                (
                    "tableau_warning_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tableauWarningId", default=None
                    ),
                ),
            )
        ),
    )
    """Update tableau asset warning

    Arguments:

    * `bi_container_id` (`UUID!`): UUID of the Tableau container for
      which this warning is being created.
    * `message` (`String!`): The new message of the warning
    * `tableau_warning_id` (`String!`): The Tableau Data Quality
      Warning ID.
    """

    generate_dc_upgrade_template = sgqlc.types.Field(
        GenerateDcUpgradeTemplate,
        graphql_name="generateDcUpgradeTemplate",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dc_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dcId", default=None),
                ),
            )
        ),
    )
    """Generates a template for DC upgrade and a URL to execute the
    template in the cloud provider.

    Arguments:

    * `dc_id` (`UUID!`): The data collector UUID
    """

    delete_data_product = sgqlc.types.Field(
        DeleteDataProduct,
        graphql_name="deleteDataProduct",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a data product

    Arguments:

    * `uuid` (`UUID!`): UUID of data product to delete
    """

    delete_data_product_v2 = sgqlc.types.Field(
        DeleteDataProductV2,
        graphql_name="deleteDataProductV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a data product

    Arguments:

    * `uuid` (`UUID!`): UUID of data product to delete
    """

    create_or_update_data_product = sgqlc.types.Field(
        CreateOrUpdateDataProduct,
        graphql_name="createOrUpdateDataProduct",
        args=sgqlc.types.ArgDict(
            (
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a data product

    Arguments:

    * `description` (`String`): Description of the data product
    * `domain_id` (`UUID`): UUID of domain to create this data product
    * `mcons` (`[String]`): MCON of assets to be part of this data
      product
    * `name` (`String`): Data product name
    * `uuid` (`UUID`): UUID of data product to update
    """

    create_or_update_data_product_v2 = sgqlc.types.Field(
        CreateOrUpdateDataProductV2,
        graphql_name="createOrUpdateDataProductV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "audience_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="audienceUuids", default=None
                    ),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "enable_monitoring_upon_creation",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="enableMonitoringUponCreation", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a data product

    Arguments:

    * `audience_uuids` (`[UUID]`): UUIDs of audiences for this data
      product
    * `description` (`String`): Description of the data product
    * `enable_monitoring_upon_creation` (`Boolean`): Whether to also
      enable monitoring all tables upon data product creation
    * `mcons` (`[String]`): MCON of assets to be part of this data
      product
    * `name` (`String`): Data product name
    * `uuid` (`UUID`): UUID of data product to update
    """

    update_data_product_sharing = sgqlc.types.Field(
        "UpdateDataProductSharing",
        graphql_name="updateDataProductSharing",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_product_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dataProductUuid", default=None
                    ),
                ),
                (
                    "shared_with_all_in_same_account",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="sharedWithAllInSameAccount",
                        default=False,
                    ),
                ),
            )
        ),
    )
    """Create or update sharing definition on a data product

    Arguments:

    * `data_product_uuid` (`UUID!`): UUID of data product to share
    * `shared_with_all_in_same_account` (`Boolean!`): Whether this
      data product is shared with all users in the same account.
      (default: `false`)
    """

    toggle_data_product_monitoring = sgqlc.types.Field(
        "ToggleDataProductMonitoring",
        graphql_name="toggleDataProductMonitoring",
        args=sgqlc.types.ArgDict(
            (
                (
                    "enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enabled", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Enables/disables automatic monitoring on a data product

    Arguments:

    * `enabled` (`Boolean!`): True of false to enable or disable
      automatic monitoring on all upstream tables
    * `uuid` (`UUID!`): UUID of data product to monitor
    """

    link_ms_teams_installation = sgqlc.types.Field(
        LinkMsTeamsInstallation,
        graphql_name="linkMsTeamsInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
                (
                    "installation_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="installationId", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `code` (`String!`): Security code passed from MS Teams
    * `installation_id` (`String!`): MS Teams App installation id
    """

    link_github_app_installation = sgqlc.types.Field(
        LinkGithubAppInstallation,
        graphql_name="linkGithubAppInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
                (
                    "installation_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="installationId", default=None
                    ),
                ),
            )
        ),
    )
    """Called from the FE as part of the post-installation callback. The
    "code" parameter is used to validate that the request is an
    authentic Github callback and authenticates the user on the Github
    side.

    Arguments:

    * `code` (`String!`): Security code passed from Github
    * `installation_id` (`String!`): Github App installation id
    """

    register_github_app_installation_request = sgqlc.types.Field(
        "RegisterGithubAppInstallationRequest",
        graphql_name="registerGithubAppInstallationRequest",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
            )
        ),
    )
    """Called from the FE as part of the post-installation callback in
    case the user requested approval from her Github admin, instead of
    approving directly. The "code" parameter is used to identify the
    Github user of the requester.

    Arguments:

    * `code` (`String!`): Security code passed from Github
    """

    update_github_installation = sgqlc.types.Field(
        "UpdateGithubAppInstallation",
        graphql_name="updateGithubInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
                (
                    "show_impact_analysis",
                    sgqlc.types.Arg(Boolean, graphql_name="showImpactAnalysis", default=None),
                ),
            )
        ),
    )
    """Updates settings for the Github app installation

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the installation
      to delete
    * `show_impact_analysis` (`Boolean`): If true, show impacted
      models and reports as a PR comment
    """

    delete_github_installation = sgqlc.types.Field(
        DeleteGithubInstallation,
        graphql_name="deleteGithubInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the installation
      to delete
    """

    register_gitlab_app = sgqlc.types.Field(
        "RegisterGitlabApp",
        graphql_name="registerGitlabApp",
        args=sgqlc.types.ArgDict(
            (
                (
                    "app_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="appId", default=None
                    ),
                ),
                (
                    "app_secret",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="appSecret", default=None
                    ),
                ),
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
            )
        ),
    )
    """(experimental) Registers a Gitlab app

    Arguments:

    * `app_id` (`String!`): Application ID generated by GitLab
    * `app_secret` (`String!`): Application secret generated by GitLab
    * `host` (`String`): Custom GitLab host
    """

    link_gitlab_app = sgqlc.types.Field(
        LinkGitlabApp,
        graphql_name="linkGitlabApp",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="state", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Links a Gitlab app

    Arguments:

    * `code` (`String!`): Security code passed from Gitlab
    * `state` (`String!`): Client account_uuid
    """

    delete_gitlab_installation = sgqlc.types.Field(
        DeleteGitlabInstallation,
        graphql_name="deleteGitlabInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Deletes a Gitlab app

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the GitLab
      installation to delete
    """

    select_gitlab_projects = sgqlc.types.Field(
        "SelectGitlabProjects",
        graphql_name="selectGitlabProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
                (
                    "repositories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(GitlabNamespaceSelection),
                        graphql_name="repositories",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Select GitLab projects for monitoring

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the GitLab
      installation
    * `repositories` (`[GitlabNamespaceSelection]`)None
    """

    update_gitlab_installation = sgqlc.types.Field(
        "UpdateGitlabInstallation",
        graphql_name="updateGitlabInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
                (
                    "show_impact_analysis",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="showImpactAnalysis",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Updates a Gitlab app

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the installation
      to update
    * `show_impact_analysis` (`Boolean!`): If true, show impacted
      models and reports as a Merge Request comment
    """

    create_azure_devops_installation = sgqlc.types.Field(
        CreateAzureDevopsInstallation,
        graphql_name="createAzureDevopsInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "basic_auth_credentials",
                    sgqlc.types.Arg(
                        AzureDevopsBasicAuthCredentialsInput,
                        graphql_name="basicAuthCredentials",
                        default=None,
                    ),
                ),
                (
                    "oauth_credentials",
                    sgqlc.types.Arg(
                        AzureDevopsOauthCredentialsInput,
                        graphql_name="oauthCredentials",
                        default=None,
                    ),
                ),
                (
                    "organization_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="organizationName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Creates an Azure DevOps installation

    Arguments:

    * `basic_auth_credentials`
      (`AzureDevopsBasicAuthCredentialsInput`)None
    * `oauth_credentials` (`AzureDevopsOauthCredentialsInput`)None
    * `organization_name` (`String!`): Azure DevOps organization name
    """

    update_azure_devops_installation = sgqlc.types.Field(
        "UpdateAzureDevopsInstallation",
        graphql_name="updateAzureDevopsInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "basic_auth_credentials",
                    sgqlc.types.Arg(
                        AzureDevopsBasicAuthCredentialsInput,
                        graphql_name="basicAuthCredentials",
                        default=None,
                    ),
                ),
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
                (
                    "oauth_credentials",
                    sgqlc.types.Arg(
                        AzureDevopsOauthCredentialsInput,
                        graphql_name="oauthCredentials",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Updates an Azure DevOps installation

    Arguments:

    * `basic_auth_credentials`
      (`AzureDevopsBasicAuthCredentialsInput`): Provide either basic
      credentials or OAuth credentials
    * `installation_uuid` (`UUID!`): Internal UUID of the installation
      to update
    * `oauth_credentials` (`AzureDevopsOauthCredentialsInput`):
      Provide either basic credentials or OAuth credentials
    """

    link_azure_devops_installation = sgqlc.types.Field(
        LinkAzureDevopsInstallation,
        graphql_name="linkAzureDevopsInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="state", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Completes the Azure DevOps OAuth authorization flow

    Arguments:

    * `code` (`String!`): OAuth code from callback URL
    * `state` (`String!`): OAuth state from callback URL
    """

    delete_azure_devops_installation = sgqlc.types.Field(
        DeleteAzureDevopsInstallation,
        graphql_name="deleteAzureDevopsInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Deletes an Azure DevOps installation

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the Azure DevOps
      installation to delete
    """

    set_azure_devops_source_selections = sgqlc.types.Field(
        "SetAzureDevopsSourceSelections",
        graphql_name="setAzureDevopsSourceSelections",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
                (
                    "selections",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(AzureDevopsSourceSelectionInput),
                        graphql_name="selections",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set which Azure Devops projects/repositories are
    selected for monitoring

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the Azure DevOps
      installation
    * `selections` (`[AzureDevopsSourceSelectionInput]`)None
    """

    update_data_share = sgqlc.types.Field(
        "UpdateDataShare",
        graphql_name="updateDataShare",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UpdateDataShareInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(general availability) Update data sharing configuration for an
    account

    Arguments:

    * `input` (`UpdateDataShareInput!`): Data share configuration
    """

    test_confluent_kafka_credentials = sgqlc.types.Field(
        "TestConfluentKafkaCredentials",
        graphql_name="testConfluentKafkaCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ConfluentKafkaCredentialsInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test a confluent Kafka cluster credentials.

    Arguments:

    * `connection_details` (`ConfluentKafkaCredentialsInput!`):
      Required Credential Info for accessing Confluent Kafka Cluster
      APIs.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_confluent_kafka_connect_credentials = sgqlc.types.Field(
        "TestConfluentKafkaConnectCredentials",
        graphql_name="testConfluentKafkaConnectCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ConfluentKafkaConnectCredentialsInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test a confluent Kafka Connect cluster credentials.

    Arguments:

    * `connection_details` (`ConfluentKafkaConnectCredentialsInput!`):
      Required Credential Info for accessing Confluent Cloud Kafka
      Connect APIs.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `validation_name` (`String!`): Validation to run for validating
      the connection.
    """

    test_msk_kafka_credentials = sgqlc.types.Field(
        "TestMskKafkaCredentials",
        graphql_name="testMskKafkaCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SelfHostedKafkaCredentialsInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test MSK Kafka cluster credentials.

    Arguments:

    * `connection_details` (`SelfHostedKafkaCredentialsInput!`):
      Required Credential Info for accessing REST Proxy in front of an
      MSK cluster
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_msk_kafka_connect_credentials = sgqlc.types.Field(
        "TestMskKafkaConnectCredentials",
        graphql_name="testMskKafkaConnectCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MskKafkaConnectCredentialsInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test MSK Kafka Connect credentials.

    Arguments:

    * `connection_details` (`MskKafkaConnectCredentialsInput!`):
      Required Credential Info for accessing MSK Kafka Connect.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `validation_name` (`String!`): Validation to run for validating
      the connection.
    """

    test_self_hosted_kafka_credentials = sgqlc.types.Field(
        "TestSelfHostedKafkaCredentials",
        graphql_name="testSelfHostedKafkaCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SelfHostedKafkaCredentialsInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Self Hosted Kafka cluster credentials.

    Arguments:

    * `connection_details` (`SelfHostedKafkaCredentialsInput!`):
      Required Credential Info for accessing Self Hosted Kafka Cluster
      APIs.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_self_hosted_kafka_connect_credentials = sgqlc.types.Field(
        "TestSelfHostedKafkaConnectCredentials",
        graphql_name="testSelfHostedKafkaConnectCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SelfHostedKafkaConnectCredentialsInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test a Self Hosted Kafka Connect cluster credentials.

    Arguments:

    * `connection_details`
      (`SelfHostedKafkaConnectCredentialsInput!`): Required Credential
      Info for accessing Self Hosted Kafka Connect APIs.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `validation_name` (`String!`): Validation to run for validating
      the connection.
    """

    add_streaming_system = sgqlc.types.Field(
        AddStreamingSystemMutation,
        graphql_name="addStreamingSystem",
        args=sgqlc.types.ArgDict(
            (
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "streaming_system_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="streamingSystemName",
                        default=None,
                    ),
                ),
                (
                    "streaming_system_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="streamingSystemType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Add a streaming system, which contains a set of streaming clusters
    that work together in the system.

    Arguments:

    * `dc_id` (`UUID`): The Data Collector UUID for the jobs of
      connections within the streaming system to run in.
    * `streaming_system_name` (`String!`): Name of the streaming
      system.
    * `streaming_system_type` (`String!`): Streaming system type.
      Supported values: [confluent-cloud, msk, self-hosted]
    """

    add_streaming_connection = sgqlc.types.Field(
        AddStreamingConnectionMutation,
        graphql_name="addStreamingConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                ("mc_cluster_id", sgqlc.types.Arg(UUID, graphql_name="mcClusterId", default=None)),
                (
                    "new_cluster_id",
                    sgqlc.types.Arg(String, graphql_name="newClusterId", default=None),
                ),
                (
                    "new_cluster_name",
                    sgqlc.types.Arg(String, graphql_name="newClusterName", default=None),
                ),
                (
                    "new_cluster_type",
                    sgqlc.types.Arg(String, graphql_name="newClusterType", default=None),
                ),
                (
                    "new_streaming_system_name",
                    sgqlc.types.Arg(String, graphql_name="newStreamingSystemName", default=None),
                ),
                (
                    "new_streaming_system_type",
                    sgqlc.types.Arg(String, graphql_name="newStreamingSystemType", default=None),
                ),
                (
                    "streaming_system_id",
                    sgqlc.types.Arg(UUID, graphql_name="streamingSystemId", default=None),
                ),
            )
        ),
    )
    """Add a connection for a streaming cluster and setup any associated
    jobs. Creates a streaming cluster if a cluster if not specified.

    Arguments:

    * `connection_type` (`String!`): Type of the new connection.
    * `dc_id` (`UUID`): Data Collector uuid to associate the streaming
      system with.
    * `job_types` (`[String]`): List of job types to create for the
      connection. If left empty, MC'd create all auto jobs.
    * `key` (`String!`): Temp key from testing connections.
    * `mc_cluster_id` (`UUID`): UUID of an existing streaming cluster.
      If this field is given, please don't set new_cluster_id,
      new_cluster_type or new_cluster_name.
    * `new_cluster_id` (`String`): Real cluster ID used in the system.
      Should be obtained from customer system. Only set when creating
      a new cluster.
    * `new_cluster_name` (`String`): Name of the cluster. Only set
      when creating a new cluster.
    * `new_cluster_type` (`String`): Type of the cluster. Only set
      when creating a new cluster. Supported types: [kafka-cluster,
      kafka-connect-cluster]
    * `new_streaming_system_name` (`String`): Name of a new streaming
      system to associate with a new cluster and the connection. Only
      set when we'd like to create a new streaming system.
    * `new_streaming_system_type` (`String`): Type of a new streaming
      system to associate with a new cluster and the connection. Only
      set when we'd like to create a new streaming system. Supported
      values: [confluent-cloud, msk, self-hosted]
    * `streaming_system_id` (`UUID`): UUID of an existing streaming
      system. If this field is given, please don't set
      new_streaming_system_type or new_streaming_system_name.
    """

    delete_streaming_system = sgqlc.types.Field(
        DeleteStreamingSystemMutation,
        graphql_name="deleteStreamingSystem",
        args=sgqlc.types.ArgDict(
            (
                (
                    "streaming_system_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="streamingSystemUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a streaming system. This will delete all clusters within
    the streaming system as well.

    Arguments:

    * `streaming_system_uuid` (`UUID!`): UUID of the streaming System
    """

    delete_streaming_cluster = sgqlc.types.Field(
        DeleteStreamingClusterMutation,
        graphql_name="deleteStreamingCluster",
        args=sgqlc.types.ArgDict(
            (
                (
                    "streaming_cluster_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID),
                        graphql_name="streamingClusterUuid",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Delete a streaming clusters, and connections on this cluster.

    Arguments:

    * `streaming_cluster_uuid` (`UUID!`): UUID of the streaming
      Cluster.
    """

    update_streaming_system_name = sgqlc.types.Field(
        "UpdateStreamingSystemNameMutation",
        graphql_name="updateStreamingSystemName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "new_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="newName", default=None
                    ),
                ),
                (
                    "streaming_system_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="streamingSystemUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Update a streaming system name.

    Arguments:

    * `new_name` (`String!`): New name of the system
    * `streaming_system_uuid` (`UUID!`): UUID of the streaming
      Cluster.
    """

    update_streaming_cluster_name = sgqlc.types.Field(
        "UpdateStreamingClusterNameMutation",
        graphql_name="updateStreamingClusterName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "new_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="newName", default=None
                    ),
                ),
                (
                    "streaming_cluster_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID),
                        graphql_name="streamingClusterUuid",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Update a streaming cluster name.

    Arguments:

    * `new_name` (`String!`): New name of the system
    * `streaming_cluster_uuid` (`UUID!`): UUID of the streaming
      cluster.
    """

    toggle_size_collection = sgqlc.types.Field(
        "ToggleSizeCollection",
        graphql_name="toggleSizeCollection",
        args=sgqlc.types.ArgDict(
            (
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enabled", default=None
                    ),
                ),
                ("force", sgqlc.types.Arg(Boolean, graphql_name="force", default=False)),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """Toggle Size Collection for an assets which doesn't support
    metadata

    Arguments:

    * `connection_id` (`UUID`): Connection to run the size collector
      on. If not provided, the default connection for SQL jobs will be
      used.
    * `enabled` (`Boolean!`): True if collection should be enabled.
      False if disabled
    * `force` (`Boolean`): Set True if table capability checks should
      be skipped. Defaults to False (default: `false`)
    * `mcon` (`String!`): MC unique identifier of the object
    * `where_condition` (`String`): Where condition which is applied
      to the collection query
    """

    create_mcp_integration_key = sgqlc.types.Field(
        CreateMcpIntegrationKey,
        graphql_name="createMcpIntegrationKey",
        args=sgqlc.types.ArgDict(
            (("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),)
        ),
    )
    """(experimental) Create an MCP integration key

    Arguments:

    * `description` (`String`): Key description
    """

    delete_mcp_integration_key = sgqlc.types.Field(
        DeleteMcpIntegrationKey,
        graphql_name="deleteMcpIntegrationKey",
        args=sgqlc.types.ArgDict(
            (
                (
                    "key_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="keyId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete an MCP integration key created by the
    current user

    Arguments:

    * `key_id` (`String!`): Integration key id
    """

    create_opsgenie_integration = sgqlc.types.Field(
        CreateOpsgenieIntegration,
        graphql_name="createOpsgenieIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationKey", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "server_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverUrl", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
                ("webhook_id", sgqlc.types.Arg(UUID, graphql_name="webhookId", default=None)),
                (
                    "webhook_secret",
                    sgqlc.types.Arg(String, graphql_name="webhookSecret", default=None),
                ),
                (
                    "webhook_secret_name",
                    sgqlc.types.Arg(String, graphql_name="webhookSecretName", default=None),
                ),
            )
        ),
    )
    """(experimental) Create an Opsgenie integration

    Arguments:

    * `integration_key` (`String!`): Integration API Key
    * `integration_name` (`String!`): Identifying name
    * `server_url` (`String!`): Base server URL
    * `webhook_enabled` (`Boolean`): If the webhook is enabled
    * `webhook_id` (`UUID`): A webhook UUID (automatically generated
      if null)
    * `webhook_secret` (`String`): The webhook secret value
    * `webhook_secret_name` (`String`): The webhook secret name
    """

    update_opsgenie_integration = sgqlc.types.Field(
        "UpdateOpsgenieIntegration",
        graphql_name="updateOpsgenieIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationKey", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "server_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverUrl", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """(experimental) Update an Opsgenie integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `integration_key` (`String!`): Integration API Key
    * `integration_name` (`String!`): Identifying name
    * `server_url` (`String!`): Base server URL
    * `webhook_enabled` (`Boolean`): If the webhook is enabled
    """

    update_opsgenie_integration_webhook_secret = sgqlc.types.Field(
        "UpdateOpsgenieIntegrationWebhookSecret",
        graphql_name="updateOpsgenieIntegrationWebhookSecret",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "webhook_secret",
                    sgqlc.types.Arg(String, graphql_name="webhookSecret", default=None),
                ),
                (
                    "webhook_secret_name",
                    sgqlc.types.Arg(String, graphql_name="webhookSecretName", default=None),
                ),
            )
        ),
    )
    """(experimental) Update an Opsgenie integration's webhook secret
    details

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `webhook_secret` (`String`): The webhook secret value
    * `webhook_secret_name` (`String`): The webhook secret name
    """

    delete_opsgenie_integration = sgqlc.types.Field(
        DeleteOpsgenieIntegration,
        graphql_name="deleteOpsgenieIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete an Opsgenie integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    link_opsgenie_incident = sgqlc.types.Field(
        LinkOpsgenieIncident,
        graphql_name="linkOpsgenieIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "opsgenie_incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="opsgenieIncidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Link an Opsgenie incident

    Arguments:

    * `opsgenie_incident_id` (`UUID!`): The Opsgenie Incident ID
    """

    unlink_opsgenie_incident = sgqlc.types.Field(
        "UnlinkOpsgenieIncident",
        graphql_name="unlinkOpsgenieIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "opsgenie_incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="opsgenieIncidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Unlink an Opsgenie incident

    Arguments:

    * `opsgenie_incident_id` (`UUID!`): The Opsgenie Incident ID
    """

    relink_opsgenie_incident = sgqlc.types.Field(
        "RelinkOpsgenieIncident",
        graphql_name="relinkOpsgenieIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Relink a Opsgenie incidents to a Monte Carlo Alert

    Arguments:

    * `alert_id` (`UUID!`): The Monte Carlo Alert ID
    """

    create_pagerduty_service_integration = sgqlc.types.Field(
        CreatePagerDutyServiceIntegration,
        graphql_name="createPagerdutyServiceIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationKey", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """Create a PagerDuty service integration

    Arguments:

    * `integration_key` (`String!`): Integration Key associated with
      the PagerDuty service to integrate
    * `integration_name` (`String!`): A short name to identify the
      integration
    * `webhook_enabled` (`Boolean`): Whether the PagerDuty webhook is
      enabled
    """

    update_pagerduty_service_integration = sgqlc.types.Field(
        "UpdatePagerDutyServiceIntegration",
        graphql_name="updatePagerdutyServiceIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationKey", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """Update a PagerDuty service integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `integration_key` (`String!`): Integration Key associated with
      the PagerDuty service to integrate
    * `integration_name` (`String!`): A short name to identify the
      integration
    * `webhook_enabled` (`Boolean`): Whether the PagerDuty webhook is
      enabled
    """

    update_pagerduty_service_integration_webhook_secret = sgqlc.types.Field(
        "UpdatePagerDutyServiceIntegrationWebhookSecret",
        graphql_name="updatePagerdutyServiceIntegrationWebhookSecret",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "webhook_secret",
                    sgqlc.types.Arg(String, graphql_name="webhookSecret", default=None),
                ),
            )
        ),
    )
    """Update the Webhook secret configured for a PagerDuty service
    integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `webhook_secret` (`String`): PagerDuty secret provided for the
      Webhook
    """

    delete_pagerduty_service_integration = sgqlc.types.Field(
        DeletePagerDutyServiceIntegration,
        graphql_name="deletePagerdutyServiceIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a PagerDuty service integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    enable_automated_volume_change_table_monitor = sgqlc.types.Field(
        EnableAutomatedVolumeChangeTableMonitor,
        graphql_name="enableAutomatedVolumeChangeTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(VolumeChangeAutomatedAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=()
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable automated volume change table monitoring an
    given asset

    Arguments:

    * `alert_condition` (`VolumeChangeAutomatedAlertConditionInput!`):
      Alert condition
    * `data_quality_dimension` (`String`): Data quality dimension for
      the alert condition
    * `mcon` (`String!`): MC unique identifier for asset
    * `tags` (`[TagKeyValuePairInput]`): Tags for the alert condition
      (default: `[]`)
    """

    enable_explicit_volume_change_table_monitor = sgqlc.types.Field(
        EnableExplicitVolumeChangeTableMonitor,
        graphql_name="enableExplicitVolumeChangeTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(VolumeChangeExplicitAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metric", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=()
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable explicit volume change table monitoring an
    given asset

    Arguments:

    * `alert_condition` (`VolumeChangeExplicitAlertConditionInput!`):
      Alert condition
    * `data_quality_dimension` (`String`): Data quality dimension for
      the alert condition
    * `mcon` (`String!`): MC unique identifier for asset
    * `metric` (`String!`): Metric to monitor
    * `tags` (`[TagKeyValuePairInput]`): Tags for the alert condition
      (default: `[]`)
    """

    disable_volume_change_table_monitor = sgqlc.types.Field(
        DisableVolumeChangeTableMonitor,
        graphql_name="disableVolumeChangeTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Disable volume change table monitoring for an asset

    Arguments:

    * `mcon` (`String!`): MC unique identifier for asset
    """

    enable_automated_ucs_table_monitor = sgqlc.types.Field(
        EnableAutomatedUCSTableMonitor,
        graphql_name="enableAutomatedUcsTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UCSAutomatedAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=()
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable automated unchanged size table monitoring an
    given asset

    Arguments:

    * `alert_condition` (`UCSAutomatedAlertConditionInput!`): Alert
      condition
    * `data_quality_dimension` (`String`): Data quality dimension for
      the alert condition
    * `mcon` (`String!`): MC unique identifier for asset
    * `tags` (`[TagKeyValuePairInput]`): Tags for the alert condition
      (default: `[]`)
    """

    enable_explicit_ucs_table_monitor = sgqlc.types.Field(
        EnableExplicitUCSTableMonitor,
        graphql_name="enableExplicitUcsTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UCSExplicitAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metric", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=()
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable explicit unchanged size table monitoring an
    given asset

    Arguments:

    * `alert_condition` (`UCSExplicitAlertConditionInput!`): Alert
      condition
    * `data_quality_dimension` (`String`): Data quality dimension for
      the alert condition
    * `mcon` (`String!`): MC unique identifier for asset
    * `metric` (`String!`): Metric to monitor
    * `tags` (`[TagKeyValuePairInput]`): Tags for the alert condition
      (default: `[]`)
    """

    disable_ucs_table_monitor = sgqlc.types.Field(
        DisableUCSTableMonitor,
        graphql_name="disableUcsTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Disable unchanged size table monitoring for an
    asset

    Arguments:

    * `mcon` (`String!`): MC unique identifier for asset
    """

    enable_automated_freshness_table_monitor = sgqlc.types.Field(
        EnableAutomatedFreshnessTableMonitor,
        graphql_name="enableAutomatedFreshnessTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(FreshnessAutomatedAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=()
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable automated freshness table monitoring an
    given asset

    Arguments:

    * `alert_condition` (`FreshnessAutomatedAlertConditionInput!`):
      Alert condition
    * `data_quality_dimension` (`String`): Data quality dimension for
      the alert condition
    * `mcon` (`String!`): MC unique identifier for asset
    * `tags` (`[TagKeyValuePairInput]`): Tags for the alert condition
      (default: `[]`)
    """

    enable_explicit_freshness_table_monitor = sgqlc.types.Field(
        EnableExplicitFreshnessTableMonitor,
        graphql_name="enableExplicitFreshnessTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(FreshnessExplicitAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=()
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable explicit freshness table monitoring an given
    asset

    Arguments:

    * `alert_condition` (`FreshnessExplicitAlertConditionInput!`):
      Alert condition
    * `data_quality_dimension` (`String`): Data quality dimension for
      the alert condition
    * `mcon` (`String!`): MC unique identifier for asset
    * `tags` (`[TagKeyValuePairInput]`): Tags for the alert condition
      (default: `[]`)
    """

    disable_freshness_table_monitor = sgqlc.types.Field(
        DisableFreshnessTableMonitor,
        graphql_name="disableFreshnessTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Disable freshness table monitoring for an asset

    Arguments:

    * `mcon` (`String!`): MC unique identifier for asset
    """

    create_servicenow_integration = sgqlc.types.Field(
        CreateServiceNowIntegration,
        graphql_name="createServicenowIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "credentials",
                    sgqlc.types.Arg(
                        ServiceNowCredentialsUnionInput, graphql_name="credentials", default=None
                    ),
                ),
                (
                    "default_alert_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultAlertFields", default=None),
                ),
                (
                    "default_incident_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultIncidentFields", default=None),
                ),
                (
                    "instance_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="instanceName", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "options",
                    sgqlc.types.Arg(
                        ServiceNowIntegrationOptionsInput, graphql_name="options", default=None
                    ),
                ),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "webhook_config",
                    sgqlc.types.Arg(
                        ServiceNowWebhookConfigInput, graphql_name="webhookConfig", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """(experimental) Create a ServiceNow integration

    Arguments:

    * `credentials` (`ServiceNowCredentialsUnionInput`): The
      ServiceNow credentials
    * `default_alert_fields` (`JSONString`): Default values for alert
      fields
    * `default_incident_fields` (`JSONString`): Default values for
      incident fields. DEPRECATED: Use defaultAlertFields instead
    * `instance_name` (`String!`): The instance name of the ServiceNow
      site
    * `integration_name` (`String!`): A short name to identify the
      integration
    * `options` (`ServiceNowIntegrationOptionsInput`): Options for
      ServiceNow integration
    * `password` (`String`): The user's password for basic
      authentication; if not provided, the previous value will be
      used. DEPRECATED: Use credentials instead.
    * `username` (`String`): The ServiceNow username for basic
      authentication; if not provided, the previous value will be
      used. DEPRECATED: Use credentials instead.
    * `webhook_config` (`ServiceNowWebhookConfigInput`): Webhook
      config
    * `webhook_enabled` (`Boolean`): Whether the ServiceNow webhook is
      enabled
    """

    update_servicenow_integration = sgqlc.types.Field(
        "UpdateServiceNowIntegration",
        graphql_name="updateServicenowIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "credentials",
                    sgqlc.types.Arg(
                        ServiceNowCredentialsUnionInput, graphql_name="credentials", default=None
                    ),
                ),
                (
                    "default_alert_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultAlertFields", default=None),
                ),
                (
                    "default_incident_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultIncidentFields", default=None),
                ),
                (
                    "instance_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="instanceName", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "options",
                    sgqlc.types.Arg(
                        ServiceNowIntegrationOptionsInput, graphql_name="options", default=None
                    ),
                ),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "webhook_config",
                    sgqlc.types.Arg(
                        ServiceNowWebhookConfigInput, graphql_name="webhookConfig", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """(experimental) Update a ServiceNow integration

    Arguments:

    * `credentials` (`ServiceNowCredentialsUnionInput`): The
      ServiceNow credentials
    * `default_alert_fields` (`JSONString`): Default values for alert
      fields
    * `default_incident_fields` (`JSONString`): Default values for
      incident fields. DEPRECATED: Use defaultAlertFields instead
    * `instance_name` (`String!`): The instance name of the ServiceNow
      site
    * `integration_id` (`UUID!`): The integration ID
    * `integration_name` (`String!`): A short name to identify the
      integration
    * `options` (`ServiceNowIntegrationOptionsInput`): Options for
      ServiceNow integration
    * `password` (`String`): The user's password for basic
      authentication; if not provided, the previous value will be
      used. DEPRECATED: Use credentials instead.
    * `username` (`String`): The ServiceNow username for basic
      authentication; if not provided, the previous value will be
      used. DEPRECATED: Use credentials instead.
    * `webhook_config` (`ServiceNowWebhookConfigInput`): Webhook
      config
    * `webhook_enabled` (`Boolean`): Whether the ServiceNow webhook is
      enabled
    """

    delete_servicenow_integration = sgqlc.types.Field(
        DeleteServiceNowIntegration,
        graphql_name="deleteServicenowIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete a ServiceNow integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    create_servicenow_incident_for_alert = sgqlc.types.Field(
        CreateServiceNowIncidentForAlert,
        graphql_name="createServicenowIncidentForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "fields",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JSONString), graphql_name="fields", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "short_description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="shortDescription", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create a ServiceNow incident for alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `description` (`String`): Description of the incident
    * `fields` (`JSONString!`): ServiceNow incident fields
    * `integration_id` (`UUID!`): ID of the ServiceNow integration
    * `short_description` (`String!`): Summary of the incident
    """

    link_servicenow_incident_for_alert = sgqlc.types.Field(
        LinkServiceNowIncidentForAlert,
        graphql_name="linkServicenowIncidentForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "incident_number",
                    sgqlc.types.Arg(String, graphql_name="incidentNumber", default=None),
                ),
                (
                    "incident_sys_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="incidentSysId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Link ServiceNow Incident for Alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `incident_number` (`String`): The incident number for
      ServiceNow. Only used if access to incidentdata is disabled for
      the integration.
    * `incident_sys_id` (`String!`): The incident sys_id for
      ServiceNow
    * `integration_id` (`UUID!`): ID of the integration
    """

    unlink_servicenow_incident_for_alert = sgqlc.types.Field(
        "UnlinkServiceNowIncidentForAlert",
        graphql_name="unlinkServicenowIncidentForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "incident_sys_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="incidentSysId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Unlink ServiceNow Incident for Alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `incident_sys_id` (`String!`): The incident sys_id for
      ServiceNow
    * `integration_id` (`UUID!`): ID of the integration
    """

    create_azure_devops_integration = sgqlc.types.Field(
        CreateAzureDevOpsIntegration,
        graphql_name="createAzureDevopsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "basic_auth_credentials",
                    sgqlc.types.Arg(
                        AzureDevOpsBasicAuthCredentialsInput,
                        graphql_name="basicAuthCredentials",
                        default=None,
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "oauth_credentials",
                    sgqlc.types.Arg(
                        AzureDevOpsOauthCredentialsInput,
                        graphql_name="oauthCredentials",
                        default=None,
                    ),
                ),
                (
                    "organization",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="organization", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create an Azure DevOps work item integration

    Arguments:

    * `basic_auth_credentials`
      (`AzureDevOpsBasicAuthCredentialsInput`): Provide either basic
      credentials or OAuth credentials
    * `integration_name` (`String!`): Identifying name
    * `oauth_credentials` (`AzureDevOpsOauthCredentialsInput`):
      Provide either basic credentials or OAuth credentials
      (preferred)
    * `organization` (`String!`): Azure DevOps organization name
    """

    update_azure_devops_integration = sgqlc.types.Field(
        "UpdateAzureDevOpsIntegration",
        graphql_name="updateAzureDevopsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "basic_auth_credentials",
                    sgqlc.types.Arg(
                        AzureDevOpsBasicAuthCredentialsInput,
                        graphql_name="basicAuthCredentials",
                        default=None,
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "oauth_credentials",
                    sgqlc.types.Arg(
                        AzureDevOpsOauthCredentialsInput,
                        graphql_name="oauthCredentials",
                        default=None,
                    ),
                ),
                (
                    "organization",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="organization", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Update an Azure DevOps work item integration

    Arguments:

    * `basic_auth_credentials`
      (`AzureDevOpsBasicAuthCredentialsInput`): New basic auth
      credentials (optional, only if rotating)
    * `integration_id` (`UUID!`): The integration ID
    * `integration_name` (`String!`): Identifying name
    * `oauth_credentials` (`AzureDevOpsOauthCredentialsInput`): New
      OAuth credentials (optional, only if rotating)
    * `organization` (`String!`): Azure DevOps organization name
    """

    link_azure_devops_integration = sgqlc.types.Field(
        LinkAzureDevOpsIntegration,
        graphql_name="linkAzureDevopsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="code", default=None
                    ),
                ),
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="state", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Complete OAuth flow for Azure DevOps work item
    integration

    Arguments:

    * `code` (`String!`): OAuth code from callback URL
    * `state` (`String!`): OAuth state from callback URL
    """

    delete_azure_devops_integration = sgqlc.types.Field(
        DeleteAzureDevOpsIntegration,
        graphql_name="deleteAzureDevopsIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete an Azure DevOps work item integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    create_azure_devops_work_item_for_alert = sgqlc.types.Field(
        CreateAzureDevOpsWorkItemForAlert,
        graphql_name="createAzureDevopsWorkItemForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "project",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="project", default=None
                    ),
                ),
                ("title", sgqlc.types.Arg(String, graphql_name="title", default=None)),
                (
                    "work_item_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="workItemType", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create Azure DevOps work item for alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `description` (`String`): Work item description
    * `integration_id` (`UUID!`): ID of the Azure DevOps integration
    * `project` (`String!`): Azure DevOps project name
    * `title` (`String`): Work item title
    * `work_item_type` (`String!`): Work item type (Bug, Task, User
      Story, etc.)
    """

    link_azure_devops_work_item_for_alert = sgqlc.types.Field(
        LinkAzureDevOpsWorkItemForAlert,
        graphql_name="linkAzureDevopsWorkItemForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "work_item_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="workItemUrl", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Link existing Azure DevOps work item to alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `integration_id` (`UUID!`): ID of the Azure DevOps integration
    * `work_item_url` (`String!`): URL of the Azure DevOps work item
    """

    unlink_azure_devops_work_item_for_alert = sgqlc.types.Field(
        "UnlinkAzureDevOpsWorkItemForAlert",
        graphql_name="unlinkAzureDevopsWorkItemForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "work_item_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="workItemId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Unlink Azure DevOps work item from alert

    Arguments:

    * `work_item_id` (`UUID!`): The work item link ID (UUID)
    """

    create_jira_integration = sgqlc.types.Field(
        CreateJiraIntegration,
        graphql_name="createJiraIntegration",
        args=sgqlc.types.ArgDict(
            (
                ("api_token", sgqlc.types.Arg(String, graphql_name="apiToken", default=None)),
                (
                    "default_ticket_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultTicketFields", default=None),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "is_token_auth",
                    sgqlc.types.Arg(Boolean, graphql_name="isTokenAuth", default=False),
                ),
                (
                    "server_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverUrl", default=None
                    ),
                ),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "webhook_config",
                    sgqlc.types.Arg(
                        JiraWebhookConfigInput, graphql_name="webhookConfig", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """Create a Jira integration

    Arguments:

    * `api_token` (`String`): The personal API token for basic
      authentication or token authentication; if not provided previous
      value will be used
    * `default_ticket_fields` (`JSONString`): Default values for
      ticket fields
    * `integration_name` (`String!`): A short name to identify the
      integration
    * `is_token_auth` (`Boolean`): Whether the integration is using
      Token Auth. Defaults to Basic Auth (default: `false`)
    * `server_url` (`String!`): The domain name for your Jira site
    * `username` (`String`): The Jira username for basic
      authentication; if not provided previous value will be used
    * `webhook_config` (`JiraWebhookConfigInput`): Webhook config
    * `webhook_enabled` (`Boolean`): Whether the Jira webhook is
      enabled
    """

    update_jira_integration = sgqlc.types.Field(
        "UpdateJiraIntegration",
        graphql_name="updateJiraIntegration",
        args=sgqlc.types.ArgDict(
            (
                ("api_token", sgqlc.types.Arg(String, graphql_name="apiToken", default=None)),
                (
                    "default_ticket_fields",
                    sgqlc.types.Arg(JSONString, graphql_name="defaultTicketFields", default=None),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationName", default=None
                    ),
                ),
                (
                    "is_token_auth",
                    sgqlc.types.Arg(Boolean, graphql_name="isTokenAuth", default=False),
                ),
                (
                    "server_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverUrl", default=None
                    ),
                ),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "webhook_config",
                    sgqlc.types.Arg(
                        JiraWebhookConfigInput, graphql_name="webhookConfig", default=None
                    ),
                ),
                (
                    "webhook_enabled",
                    sgqlc.types.Arg(Boolean, graphql_name="webhookEnabled", default=None),
                ),
            )
        ),
    )
    """Update a Jira integration

    Arguments:

    * `api_token` (`String`): The personal API token for basic
      authentication or token authentication; if not provided previous
      value will be used
    * `default_ticket_fields` (`JSONString`): Default values for
      ticket fields
    * `integration_id` (`UUID!`): The integration ID
    * `integration_name` (`String!`): A short name to identify the
      integration
    * `is_token_auth` (`Boolean`): Whether the integration is using
      Token Auth. Defaults to Basic Auth (default: `false`)
    * `server_url` (`String!`): The domain name for your Jira site
    * `username` (`String`): The Jira username for basic
      authentication; if not provided previous value will be used
    * `webhook_config` (`JiraWebhookConfigInput`): Webhook config
    * `webhook_enabled` (`Boolean`): Whether the Jira webhook is
      enabled
    """

    update_jira_integration_webhook_secret = sgqlc.types.Field(
        "UpdateJiraIntegrationWebhookSecret",
        graphql_name="updateJiraIntegrationWebhookSecret",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "webhook_secret",
                    sgqlc.types.Arg(String, graphql_name="webhookSecret", default=None),
                ),
            )
        ),
    )
    """(experimental) Update the Webhook secret configured for a JIRA
    service integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `webhook_secret` (`String`): JIRA secret provided for the
      Webhook
    """

    delete_jira_integration = sgqlc.types.Field(
        DeleteJiraIntegration,
        graphql_name="deleteJiraIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a Jira integration

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    """

    create_jira_ticket_for_incident = sgqlc.types.Field(
        CreateJiraTicketForIncident,
        graphql_name="createJiraTicketForIncident",
        args=sgqlc.types.ArgDict(
            (
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("fields", sgqlc.types.Arg(JSONString, graphql_name="fields", default=None)),
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                ("issuetype", sgqlc.types.Arg(Int, graphql_name="issuetype", default=None)),
                ("project", sgqlc.types.Arg(Int, graphql_name="project", default=None)),
                ("summary", sgqlc.types.Arg(String, graphql_name="summary", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Create jira ticket for incident

    Arguments:

    * `description` (`String`): Jira ticket description
    * `fields` (`JSONString`): Jira ticket fields
    * `incident_id` (`UUID!`): ID of the incident
    * `integration_id` (`UUID!`): ID of the integration
    * `issuetype` (`Int`): Jira issue type ID
    * `project` (`Int`): Jira project ID
    * `summary` (`String`): Jira ticket summary
    """

    create_jira_ticket_for_alert = sgqlc.types.Field(
        CreateJiraTicketForAlert,
        graphql_name="createJiraTicketForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("fields", sgqlc.types.Arg(JSONString, graphql_name="fields", default=None)),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                ("issuetype", sgqlc.types.Arg(Int, graphql_name="issuetype", default=None)),
                ("project", sgqlc.types.Arg(Int, graphql_name="project", default=None)),
                ("summary", sgqlc.types.Arg(String, graphql_name="summary", default=None)),
            )
        ),
    )
    """(experimental) Create jira ticket for alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `description` (`String`): Jira ticket description
    * `fields` (`JSONString`): Jira ticket fields
    * `integration_id` (`UUID!`): ID of the integration
    * `issuetype` (`Int`): Jira issue type ID
    * `project` (`Int`): Jira project ID
    * `summary` (`String`): Jira ticket summary
    """

    link_jira_ticket_for_incident = sgqlc.types.Field(
        LinkJiraTicketForIncident,
        graphql_name="linkJiraTicketForIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "ticket_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="ticketUrl", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `incident_id` (`UUID!`): ID of the incident
    * `integration_id` (`UUID!`): ID of the integration
    * `ticket_url` (`String!`): URL of the Jira ticket
    """

    link_jira_ticket_for_alert = sgqlc.types.Field(
        LinkJiraTicketForAlert,
        graphql_name="linkJiraTicketForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "ticket_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="ticketUrl", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Link Jira Ticket for Alert

    Arguments:

    * `alert_id` (`UUID!`): ID of the alert
    * `integration_id` (`UUID!`): ID of the integration
    * `ticket_url` (`String!`): URL of the Jira ticket
    """

    unlink_jira_ticket_for_incident = sgqlc.types.Field(
        "UnlinkJiraTicketForIncident",
        graphql_name="unlinkJiraTicketForIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "ticket_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="ticketId", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `ticket_id` (`UUID!`): The ticket ID
    """

    unlink_jira_ticket_for_alert = sgqlc.types.Field(
        "UnlinkJiraTicketForAlert",
        graphql_name="unlinkJiraTicketForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "ticket_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="ticketId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Unlink Jira Ticket for Alert

    Arguments:

    * `ticket_id` (`UUID!`): The ticket ID
    """

    create_or_update_notification_setting = sgqlc.types.Field(
        CreateOrUpdateNotificationSetting,
        graphql_name="createOrUpdateNotificationSetting",
        args=sgqlc.types.ArgDict(
            (
                (
                    "anomaly_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="anomalyTypes", default=None
                    ),
                ),
                ("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),
                (
                    "custom_message",
                    sgqlc.types.Arg(String, graphql_name="customMessage", default=None),
                ),
                (
                    "digest_settings",
                    sgqlc.types.Arg(
                        NotificationDigestSettings, graphql_name="digestSettings", default=None
                    ),
                ),
                ("dry", sgqlc.types.Arg(Boolean, graphql_name="dry", default=False)),
                ("extra", sgqlc.types.Arg(NotificationExtra, graphql_name="extra", default=None)),
                (
                    "incident_sub_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentSubType),
                        graphql_name="incidentSubTypes",
                        default=None,
                    ),
                ),
                (
                    "integration_id",
                    sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None),
                ),
                (
                    "notification_schedule_type",
                    sgqlc.types.Arg(String, graphql_name="notificationScheduleType", default=None),
                ),
                (
                    "notification_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="notificationType", default=None
                    ),
                ),
                ("recipient", sgqlc.types.Arg(String, graphql_name="recipient", default=None)),
                (
                    "recipients",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="recipients", default=None
                    ),
                ),
                (
                    "rules",
                    sgqlc.types.Arg(NotificationRoutingRules, graphql_name="rules", default=None),
                ),
                ("setting_id", sgqlc.types.Arg(UUID, graphql_name="settingId", default=None)),
            )
        ),
    )
    """Create or update a notification setting

    Arguments:

    * `anomaly_types` (`[String]`): Limit notifications to specific
      incident types (default=all). Supported options include:
      anomalies, schema_changes, json_schema_changes, deleted_tables,
      metric_anomalies, agent_anomalies, metric_comparison_anomalies,
      custom_rule_anomalies, performance_anomalies, dbt_errors,
      etl_errors, pseudo_integration_test, rule_run_execution_error,
      merged
    * `audience_id` (`UUID`): Audience associated with the recipient
    * `custom_message` (`String`): A custom message to be sent with
      triggered notification
    * `digest_settings` (`NotificationDigestSettings`): Digest
      settings. Only valid when notification schedule type is digest
    * `dry` (`Boolean`): Test destination is reachable by sending a
      sample alert. Note - setting is not saved and rules are not
      evaluated. (default: `false`)
    * `extra` (`NotificationExtra`): Any extra values
    * `incident_sub_types` (`[IncidentSubType]`): Limit notifications
      to specific incident sub types (default=all). Deprecated. No
      longer supported for notification settings.
    * `integration_id` (`UUID`): Integration ID for the recipient
    * `notification_schedule_type` (`String`): Specify the
      notification schedule type. Supported values: realtime, digest,
      backup_or_failure
    * `notification_type` (`String!`): Specify the notification
      integration to use. Supported options include: email, opsgenie,
      pagerduty, slack, slack_v2, google_chat, webhook, msteams,
      msteams_v2, alation, servicenow, jira, webex, incidentio,
      datadog, azure_devops
    * `recipient` (`String`): Deprecated
    * `recipients` (`[String]`): Destination to send notifications to
    * `rules` (`NotificationRoutingRules`): Routing rules
    * `setting_id` (`UUID`): For updating a notification setting
    """

    create_or_update_recipient_name = sgqlc.types.Field(
        CreateOrUpdateRecipientName,
        graphql_name="createOrUpdateRecipientName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                (
                    "recipient",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="recipient", default=None
                    ),
                ),
            )
        ),
    )
    """Create or update a recipient's custom name

    Arguments:

    * `name` (`String!`): Custom name
    * `recipient` (`String!`): Recipient string
    """

    delete_notification_settings = sgqlc.types.Field(
        DeleteNotificationSetting,
        graphql_name="deleteNotificationSettings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `uuids` (`[UUID]!`)None
    """

    delete_recipient_name = sgqlc.types.Field(
        DeleteRecipientName,
        graphql_name="deleteRecipientName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "recipient",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="recipient", default=None
                    ),
                ),
            )
        ),
    )
    """Create or update a recipient's custom name

    Arguments:

    * `recipient` (`String!`): Recipient string
    """

    create_or_update_audience = sgqlc.types.Field(
        CreateOrUpdateAudience,
        graphql_name="createOrUpdateAudience",
        args=sgqlc.types.ArgDict(
            (
                (
                    "label",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="label", default=None
                    ),
                ),
                (
                    "notification_settings",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(AudienceNotificationSettingInput)),
                        graphql_name="notificationSettings",
                        default=None,
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create a notification audience

    Arguments:

    * `label` (`String!`): Label for the audience
    * `notification_settings` (`[AudienceNotificationSettingInput]!`):
      Notification settings for the audience
    * `uuid` (`UUID`): For updating an audience
    """

    create_or_update_audience_notification_setting = sgqlc.types.Field(
        CreateOrUpdateAudienceNotificationSetting,
        graphql_name="createOrUpdateAudienceNotificationSetting",
        args=sgqlc.types.ArgDict(
            (
                ("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),
                (
                    "custom_display_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="customDisplayNames", default=None
                    ),
                ),
                ("dry", sgqlc.types.Arg(Boolean, graphql_name="dry", default=False)),
                ("extra", sgqlc.types.Arg(NotificationExtra, graphql_name="extra", default=None)),
                (
                    "integration_id",
                    sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None),
                ),
                (
                    "notification_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="notificationType", default=None
                    ),
                ),
                (
                    "recipients",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="recipients",
                        default=None,
                    ),
                ),
                (
                    "recipients_display_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="recipientsDisplayNames",
                        default=None,
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update an audience notification setting

    Arguments:

    * `audience_id` (`UUID`): Audience associated with the recipient
    * `custom_display_names` (`[String]`): Display names for the
      recipients. If this input parameter is provided, it should
      contain an entry for each recipient in the same order as the
      `recipients` list
    * `dry` (`Boolean`): Test destination is reachable by sending a
      sample alert. Note - setting is not saved and rules are not
      evaluated. (default: `false`)
    * `extra` (`NotificationExtra`): Any extra values
    * `integration_id` (`UUID`): Integration ID for the recipient
    * `notification_type` (`String!`): Specify the notification
      integration to use. Supported options include: email, opsgenie,
      pagerduty, slack, slack_v2, google_chat, webhook, msteams,
      msteams_v2, alation, servicenow, jira, webex, incidentio,
      datadog, azure_devops
    * `recipients` (`[String]!`): Destination to send notifications to
    * `recipients_display_names` (`[String]`): Display names for the
      recipients. If this input parameter is provided, it should
      contain an entry for each recipient in the same order as the
      `recipients` list
    * `uuid` (`UUID`): For updating a notification setting
    """

    delete_audience_notification_setting = sgqlc.types.Field(
        DeleteAudienceNotificationSetting,
        graphql_name="deleteAudienceNotificationSetting",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `uuids` (`[UUID]!`)None
    """

    create_or_update_audience_routing_rule = sgqlc.types.Field(
        CreateOrUpdateAudienceRoutingRule,
        graphql_name="createOrUpdateAudienceRoutingRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_sub_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(AlertSubType),
                        graphql_name="alertSubTypes",
                        default=None,
                    ),
                ),
                (
                    "all_tag_key_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.list_of(NotificationTagPairs)),
                        graphql_name="allTagKeyValues",
                        default=None,
                    ),
                ),
                (
                    "anomaly_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="anomalyTypes", default=None
                    ),
                ),
                (
                    "assets_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="assetsMcons", default=None
                    ),
                ),
                (
                    "audience_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="audienceId", default=None
                    ),
                ),
                (
                    "custom_message",
                    sgqlc.types.Arg(String, graphql_name="customMessage", default=None),
                ),
                (
                    "dataset_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="datasetIds", default=None
                    ),
                ),
                (
                    "digest_settings",
                    sgqlc.types.Arg(
                        NotificationDigestSettings, graphql_name="digestSettings", default=None
                    ),
                ),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "exclude_all_tag_key_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.list_of(NotificationTagPairs)),
                        graphql_name="excludeAllTagKeyValues",
                        default=None,
                    ),
                ),
                (
                    "exclude_assets_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeAssetsMcons", default=None
                    ),
                ),
                (
                    "exclude_dataset_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="excludeDatasetIds", default=None
                    ),
                ),
                (
                    "exclude_full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="excludeFullTableIds",
                        default=None,
                    ),
                ),
                (
                    "exclude_project_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="excludeProjectMcons",
                        default=None,
                    ),
                ),
                (
                    "exclude_project_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="excludeProjectNames",
                        default=None,
                    ),
                ),
                (
                    "exclude_table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeTableMcons", default=None
                    ),
                ),
                (
                    "exclude_tag_key_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(NotificationTagPairs),
                        graphql_name="excludeTagKeyValues",
                        default=None,
                    ),
                ),
                (
                    "exclude_tag_keys",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeTagKeys", default=None
                    ),
                ),
                (
                    "full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fullTableIds", default=None
                    ),
                ),
                (
                    "incident_sub_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentSubType),
                        graphql_name="incidentSubTypes",
                        default=None,
                    ),
                ),
                (
                    "project_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="projectMcons", default=None
                    ),
                ),
                (
                    "project_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="projectNames", default=None
                    ),
                ),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
                ("table_regex", sgqlc.types.Arg(String, graphql_name="tableRegex", default=None)),
                (
                    "table_stats_rules",
                    sgqlc.types.Arg(TableStatsRules, graphql_name="tableStatsRules", default=None),
                ),
                (
                    "tag_key_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(NotificationTagPairs),
                        graphql_name="tagKeyValues",
                        default=None,
                    ),
                ),
                (
                    "tag_keys",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tagKeys", default=None
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update an audience routing rule

    Arguments:

    * `alert_sub_types` (`[AlertSubType]`): Limit notifications to
      specific alert sub types (default=all).
    * `all_tag_key_values` (`[[NotificationTagPairs]]`)None
    * `anomaly_types` (`[String]`): Limit notifications to specific
      incident types (default=all). Supported options include:
      anomalies, schema_changes, json_schema_changes, deleted_tables,
      metric_anomalies, agent_anomalies, metric_comparison_anomalies,
      custom_rule_anomalies, performance_anomalies, dbt_errors,
      etl_errors, pseudo_integration_test, rule_run_execution_error,
      merged
    * `assets_mcons` (`[String]`): Allowlist by asset mcons
    * `audience_id` (`UUID!`): Audience associated with the rule
    * `custom_message` (`String`): A custom message to be sent with
      triggered notification
    * `dataset_ids` (`[UUID]`): Allowlist by dataset identifiers
    * `digest_settings` (`NotificationDigestSettings`): Digest
      settings.
    * `domain_ids` (`[UUID]`): Allowlist by domain identifiers
    * `exclude_all_tag_key_values` (`[[NotificationTagPairs]]`)None
    * `exclude_assets_mcons` (`[String]`): Denylist by asset mcons
    * `exclude_dataset_ids` (`[UUID]`): Denylist by dataset
      identifiers
    * `exclude_full_table_ids` (`[String]`): Denylist by full table
      identifiers
    * `exclude_project_mcons` (`[String]`): Denylist by project mcons
    * `exclude_project_names` (`[String]`): Denylist by project names
    * `exclude_table_mcons` (`[String]`): Denylist by table mcon
      identifiers
    * `exclude_tag_key_values` (`[NotificationTagPairs]`): Denylist by
      tag key/value pairs
    * `exclude_tag_keys` (`[String]`): Denylist by tag keys
    * `full_table_ids` (`[String]`): Allowlist by full table
      identifiers
    * `incident_sub_types` (`[IncidentSubType]`): Limit notifications
      to specific incident sub types (default=all). Deprecated, use
      alertSubTypes instead.
    * `project_mcons` (`[String]`): Allowlist by project mcons
    * `project_names` (`[String]`): Allowlist by project names
    * `table_mcons` (`[String]`): Allowlist by table mcons
    * `table_regex` (`String`): For use in updating regex based rules
    * `table_stats_rules` (`TableStatsRules`): Allowlist by table
      stats (importance_score, is_important).
    * `tag_key_values` (`[NotificationTagPairs]`): Allowlist by tag
      key/value pairs
    * `tag_keys` (`[String]`): Allowlist by tag keys
    * `uuid` (`UUID`): Rule ID to update a routing rule
    """

    delete_audience_routing_rule = sgqlc.types.Field(
        DeleteAudienceRoutingRule,
        graphql_name="deleteAudienceRoutingRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `uuids` (`[UUID]!`)None
    """

    set_default_failure_audiences = sgqlc.types.Field(
        "SetDefaultFailureAudiences",
        graphql_name="setDefaultFailureAudiences",
        args=sgqlc.types.ArgDict(
            (
                (
                    "audience_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="audienceIds",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set default failure audiences (labels) for the
    account

    Arguments:

    * `audience_ids` (`[UUID!]!`): Audience (labels) UUIDs to set as
      default for failure notifications
    """

    set_pii_filter_status = sgqlc.types.Field(
        "SetPiiFilterStatus",
        graphql_name="setPiiFilterStatus",
        args=sgqlc.types.ArgDict(
            (
                (
                    "pii_filter_status_pairs",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(PiiFilterStatusPair)),
                        graphql_name="piiFilterStatusPairs",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Set PII filter status for this account.

    Arguments:

    * `pii_filter_status_pairs` (`[PiiFilterStatusPair]!`): PII Filter
      statuses to set for the account.
    """

    update_pii_filtering_preferences = sgqlc.types.Field(
        "UpdatePiiFilteringPreferences",
        graphql_name="updatePiiFilteringPreferences",
        args=sgqlc.types.ArgDict(
            (
                ("enabled", sgqlc.types.Arg(Boolean, graphql_name="enabled", default=None)),
                (
                    "fail_mode",
                    sgqlc.types.Arg(
                        PiiFilteringFailModeType, graphql_name="failMode", default=None
                    ),
                ),
            )
        ),
    )
    """Update account-wide PII filtering options.

    Arguments:

    * `enabled` (`Boolean`): Whether PII filtering should be enabled
      for the account.
    * `fail_mode` (`PiiFilteringFailModeType`): Whether PII filter
      failures will allow (open) or prevent (close) data flow for this
      account.
    """

    update_monitor_name = sgqlc.types.Field(
        "UpdateMonitorName",
        graphql_name="updateMonitorName",
        args=sgqlc.types.ArgDict(
            (
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Set the monitor description

    Arguments:

    * `monitor_type` (`String`): DEPRECATED: field is ignored
    * `monitor_uuid` (`UUID!`): UUID of the metric monitor or custom
      rule
    * `name` (`String!`): The new monitor name (the description field)
    """

    update_monitor_description = sgqlc.types.Field(
        "UpdateMonitorDescription",
        graphql_name="updateMonitorDescription",
        args=sgqlc.types.ArgDict(
            (
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Set the monitor description

    Arguments:

    * `description` (`String!`): The new monitor name (the description
      field)
    * `monitor_type` (`String`): DEPRECATED: field is ignored
    * `monitor_uuid` (`UUID!`): UUID of the metric monitor or custom
      rule
    """

    update_monitor_notes = sgqlc.types.Field(
        "UpdateMonitorNotes",
        graphql_name="updateMonitorNotes",
        args=sgqlc.types.ArgDict(
            (
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "notes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="notes", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Set the monitor notes

    Arguments:

    * `monitor_type` (`String`): DEPRECATED: field is ignored
    * `monitor_uuid` (`UUID!`): UUID of the metric monitor or custom
      rule
    * `notes` (`String!`): The notes for the monitor
    """

    update_monitor_labels = sgqlc.types.Field(
        "UpdateMonitorLabels",
        graphql_name="updateMonitorLabels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="labels",
                        default=None,
                    ),
                ),
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Set the monitor labels

    Arguments:

    * `labels` (`[String]!`): Labels to insert on the monitor
    * `monitor_type` (`String`): DEPRECATED: field is ignored
    * `monitor_uuid` (`UUID!`): UUID of the metric monitor or custom
      rule
    """

    run_monitor = sgqlc.types.Field(
        "RunMonitor",
        graphql_name="runMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Run a monitor manually

    Arguments:

    * `monitor_uuid` (`UUID!`): Monitor UUID to run
    """

    update_monitors_priorities = sgqlc.types.Field(
        "UpdateMonitorsPriorities",
        graphql_name="updateMonitorsPriorities",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
            )
        ),
    )
    """(experimental) Set the priorities of monitors

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): UUIDs of the metric monitors or
      custom rules
    * `priority` (`String`): The new priority for the monitors
    """

    update_monitors_schedules = sgqlc.types.Field(
        "UpdateMonitorsSchedules",
        graphql_name="updateMonitorsSchedules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set the schedules of monitors

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): UUIDs of the metric monitors or
      custom rules
    * `schedule_config` (`ScheduleConfigInput!`): Schedule
    """

    pause_monitors = sgqlc.types.Field(
        "PauseMonitors",
        graphql_name="pauseMonitors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
                (
                    "pause",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="pause", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Pause/unpause monitors

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): UUIDs of the metric monitor or
      custom rule
    * `pause` (`Boolean!`): Pause state of the monitors
    """

    delete_monitors = sgqlc.types.Field(
        DeleteMonitors,
        graphql_name="deleteMonitors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(general availability) Delete monitors

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): UUIDs of the metric monitor or
      custom rule
    """

    run_monitors = sgqlc.types.Field(
        "RunMonitors",
        graphql_name="runMonitors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Run the specified monitors now

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): Monitor UUIDs to run
    """

    create_or_update_monitor_comment = sgqlc.types.Field(
        CreateOrUpdateMonitorComment,
        graphql_name="createOrUpdateMonitorComment",
        args=sgqlc.types.ArgDict(
            (
                ("comment_uuid", sgqlc.types.Arg(UUID, graphql_name="commentUuid", default=None)),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "text",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="text", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Creates or updates a comment on a monitor

    Arguments:

    * `comment_uuid` (`UUID`): UUID of the comment. If set, this call
      is for updating the comment
    * `monitor_uuid` (`UUID!`): The monitor's UUID
    * `text` (`String!`): Content of the comment
    """

    delete_monitor_comment = sgqlc.types.Field(
        DeleteMonitorComment,
        graphql_name="deleteMonitorComment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comment_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="commentUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Deletes a monitor comment

    Arguments:

    * `comment_uuid` (`UUID!`): UUID of the comment to delete
    """

    create_custom_user = sgqlc.types.Field(
        CreateCustomUser,
        graphql_name="createCustomUser",
        args=sgqlc.types.ArgDict(
            (
                (
                    "email",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="email", default=None
                    ),
                ),
                ("first_name", sgqlc.types.Arg(String, graphql_name="firstName", default=None)),
                ("last_name", sgqlc.types.Arg(String, graphql_name="lastName", default=None)),
            )
        ),
    )
    """Create a CustomUser

    Arguments:

    * `email` (`String!`): Email
    * `first_name` (`String`): First name
    * `last_name` (`String`): Last name
    """

    create_unified_user_assignment = sgqlc.types.Field(
        CreateUnifiedUserAssignment,
        graphql_name="createUnifiedUserAssignment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "object_mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="objectMcon", default=None
                    ),
                ),
                (
                    "relationship_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(RelationshipType),
                        graphql_name="relationshipType",
                        default=None,
                    ),
                ),
                (
                    "unified_user_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="unifiedUserId", default=None
                    ),
                ),
            )
        ),
    )
    """Associate a UnifiedUser with a CatalogObject

    Arguments:

    * `object_mcon` (`String!`): MCON of catalog object
    * `relationship_type` (`RelationshipType!`): Type of relationship
    * `unified_user_id` (`String!`): UUID of UnifiedUser
    """

    delete_unified_user_assignment = sgqlc.types.Field(
        DeleteUnifiedUserAssignment,
        graphql_name="deleteUnifiedUserAssignment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "object_mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="objectMcon", default=None
                    ),
                ),
                (
                    "unified_user_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="unifiedUserId", default=None
                    ),
                ),
            )
        ),
    )
    """Associate a UnifiedUser with a CatalogObject

    Arguments:

    * `object_mcon` (`String!`): MCON of catalog object
    * `unified_user_id` (`String!`): UUID of UnifiedUser
    """

    send_dbt_artifacts_event = sgqlc.types.Field(
        "SendDbtArtifactsEvent",
        graphql_name="sendDbtArtifactsEvent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "artifacts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DbtArtifactsInput),
                        graphql_name="artifacts",
                        default=None,
                    ),
                ),
                (
                    "invocation_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="invocationId", default=None
                    ),
                ),
                (
                    "job_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobName", default=None
                    ),
                ),
                (
                    "project_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="projectName", default=None
                    ),
                ),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
            )
        ),
    )
    """Publish a Dbt artifacts event to Kinesis stream

    Arguments:

    * `artifacts` (`DbtArtifactsInput!`): Artifacts to publish
    * `invocation_id` (`UUID!`): dbt invocation id
    * `job_name` (`String!`): dbt job name
    * `project_name` (`String!`): dbt project name
    * `resource_id` (`UUID`): Optional resource uuid
    """

    set_group_repetitive_dbt_model_failures = sgqlc.types.Field(
        "SetGroupRepetitiveDbtModelFailures",
        graphql_name="setGroupRepetitiveDbtModelFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "group_repetitive_failures",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="groupRepetitiveFailures",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Set whether to group dbt model failures with the same error
    message into the same incident

    Arguments:

    * `connection_id` (`UUID!`): dbt connection id
    * `group_repetitive_failures` (`Boolean!`): Failures with the same
      error message should be grouped together
    """

    set_group_repetitive_dbt_test_failures = sgqlc.types.Field(
        "SetGroupRepetitiveDbtTestFailures",
        graphql_name="setGroupRepetitiveDbtTestFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "group_repetitive_failures",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="groupRepetitiveFailures",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Set whether to group dbt test failures with the same error message
    into the same incident

    Arguments:

    * `connection_id` (`UUID!`): dbt connection id
    * `group_repetitive_failures` (`Boolean!`): Failures with the same
      error message should be grouped together
    """

    set_group_repetitive_dbt_test_warnings = sgqlc.types.Field(
        "SetGroupRepetitiveDbtTestWarnings",
        graphql_name="setGroupRepetitiveDbtTestWarnings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "group_repetitive_failures",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="groupRepetitiveFailures",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Set whether to group dbt test warnings with the same error message
    into the same incident

    Arguments:

    * `connection_id` (`UUID!`): dbt connection id
    * `group_repetitive_failures` (`Boolean!`): Test warnings with the
      same error message should be grouped together
    """

    set_group_repetitive_dbt_snapshot_failures = sgqlc.types.Field(
        "SetGroupRepetitiveDbtSnapshotFailures",
        graphql_name="setGroupRepetitiveDbtSnapshotFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "group_repetitive_failures",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="groupRepetitiveFailures",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set whether to group dbt snapshot failures with the
    same error message into the same incident

    Arguments:

    * `connection_id` (`UUID!`): dbt connection id
    * `group_repetitive_failures` (`Boolean!`): Failures with the same
      error message should be grouped together
    """

    set_group_repetitive_dbt_seed_failures = sgqlc.types.Field(
        "SetGroupRepetitiveDbtSeedFailures",
        graphql_name="setGroupRepetitiveDbtSeedFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "group_repetitive_failures",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="groupRepetitiveFailures",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set whether to group dbt seed failures with the
    same error message into the same incident

    Arguments:

    * `connection_id` (`UUID!`): dbt connection id
    * `group_repetitive_failures` (`Boolean!`): Failures with the same
      error message should be grouped together
    """

    set_project_generate_incidents_for_model_failures = sgqlc.types.Field(
        "SetProjectGenerateIncidentsForModelFailures",
        graphql_name="setProjectGenerateIncidentsForModelFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_incidents",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="generateIncidents",
                        default=None,
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Set whether a dbt project generates
    incidents for model failures

    Arguments:

    * `generate_incidents` (`Boolean!`): should generate incidents
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_alerts_for_model_failures = sgqlc.types.Field(
        "SetProjectGenerateAlertsForModelFailures",
        graphql_name="setProjectGenerateAlertsForModelFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generateAlerts", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Set whether a dbt project generates alerts for
    model failures

    Arguments:

    * `generate_alerts` (`Boolean!`): should generate alerts
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_incidents_for_test_failures = sgqlc.types.Field(
        "SetProjectGenerateIncidentsForTestFailures",
        graphql_name="setProjectGenerateIncidentsForTestFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_incidents",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="generateIncidents",
                        default=None,
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Set whether a dbt project generates
    incidents for test failures

    Arguments:

    * `generate_incidents` (`Boolean!`): should generate incidents
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_alerts_for_test_failures = sgqlc.types.Field(
        "SetProjectGenerateAlertsForTestFailures",
        graphql_name="setProjectGenerateAlertsForTestFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generateAlerts", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Set whether a dbt project generates alerts for test
    failures

    Arguments:

    * `generate_alerts` (`Boolean!`): should generate alerts
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_incidents_for_test_warnings = sgqlc.types.Field(
        "SetProjectGenerateIncidentsForTestWarnings",
        graphql_name="setProjectGenerateIncidentsForTestWarnings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_incidents",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="generateIncidents",
                        default=None,
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Set whether a dbt project generates
    incidents for test warnings

    Arguments:

    * `generate_incidents` (`Boolean!`): should generate incidents
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_alerts_for_test_warnings = sgqlc.types.Field(
        "SetProjectGenerateAlertsForTestWarnings",
        graphql_name="setProjectGenerateAlertsForTestWarnings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generateAlerts", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Set whether a dbt project generates alerts for test
    warnings

    Arguments:

    * `generate_alerts` (`Boolean!`): should generate alerts
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_alerts_for_snapshot_failures = sgqlc.types.Field(
        "SetProjectGenerateAlertsForSnapshotFailures",
        graphql_name="setProjectGenerateAlertsForSnapshotFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generateAlerts", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Set whether a dbt project generates alerts for
    snapshot failures

    Arguments:

    * `generate_alerts` (`Boolean!`): should generate alerts for
      snapshot failures
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_project_generate_alerts_for_seed_failures = sgqlc.types.Field(
        "SetProjectGenerateAlertsForSeedFailures",
        graphql_name="setProjectGenerateAlertsForSeedFailures",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generate_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generateAlerts", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Set whether a dbt project generates alerts for seed
    failures

    Arguments:

    * `generate_alerts` (`Boolean!`): should generate alerts for seed
      failures
    * `uuid` (`UUID!`): dbt project uuid
    """

    set_job_generates_incidents = sgqlc.types.Field(
        "SetJobGeneratesIncidents",
        graphql_name="setJobGeneratesIncidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generates_incidents",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="generatesIncidents",
                        default=None,
                    ),
                ),
                (
                    "job_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="jobId", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Set whether a dbt job generates
    incidents

    Arguments:

    * `generates_incidents` (`Boolean!`): should generate incidents
    * `job_id` (`UUID!`): dbt job id
    """

    set_job_generates_alerts = sgqlc.types.Field(
        "SetJobGeneratesAlerts",
        graphql_name="setJobGeneratesAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generates_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts", default=None
                    ),
                ),
                (
                    "job_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="jobId", default=None),
                ),
            )
        ),
    )
    """Set whether a dbt job generates alerts

    Arguments:

    * `generates_alerts` (`Boolean!`): should generate alerts
    * `job_id` (`UUID!`): dbt job id
    """

    snooze_dbt_node = sgqlc.types.Field(
        "SnoozeDbtNode",
        graphql_name="snoozeDbtNode",
        args=sgqlc.types.ArgDict(
            (
                ("dbt_node_uuid", sgqlc.types.Arg(UUID, graphql_name="dbtNodeUuid", default=None)),
                (
                    "snooze_minutes",
                    sgqlc.types.Arg(Int, graphql_name="snoozeMinutes", default=None),
                ),
            )
        ),
    )
    """Snooze a DBT node (model/test). Data collection will continue, but
    no events will be reported.

    Arguments:

    * `dbt_node_uuid` (`UUID`): UUID for DBT node to snooze
    * `snooze_minutes` (`Int`): Number of minutes to snooze
    """

    unsnooze_dbt_node = sgqlc.types.Field(
        "UnsnoozeDbtNode",
        graphql_name="unsnoozeDbtNode",
        args=sgqlc.types.ArgDict(
            (("dbt_node_uuid", sgqlc.types.Arg(UUID, graphql_name="dbtNodeUuid", default=None)),)
        ),
    )
    """Un-snooze a DBT node (model/test).

    Arguments:

    * `dbt_node_uuid` (`UUID`): UUID for DBT node to un-snooze
    """

    update_dbt_project_info = sgqlc.types.Field(
        "UpdateDbtProjectInfo",
        graphql_name="updateDbtProjectInfo",
        args=sgqlc.types.ArgDict(
            (
                ("remote_url", sgqlc.types.Arg(String, graphql_name="remoteUrl", default=None)),
                (
                    "subdirectory",
                    sgqlc.types.Arg(String, graphql_name="subdirectory", default=None),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Set extra information about dbt project

    Arguments:

    * `remote_url` (`String`): Remote location of the project sources
    * `subdirectory` (`String`): Subdirectory of the project sources
    * `uuid` (`UUID!`): dbt project id
    """

    create_or_update_monte_carlo_config_template = sgqlc.types.Field(
        CreateOrUpdateMonteCarloConfigTemplate,
        graphql_name="createOrUpdateMonteCarloConfigTemplate",
        args=sgqlc.types.ArgDict(
            (
                (
                    "config_template_json",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="configTemplateJson",
                        default=None,
                    ),
                ),
                (
                    "create_non_ingested_tables",
                    sgqlc.types.Arg(Boolean, graphql_name="createNonIngestedTables", default=None),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=None)),
                (
                    "misconfigured_as_warning",
                    sgqlc.types.Arg(Boolean, graphql_name="misconfiguredAsWarning", default=None),
                ),
                (
                    "namespace",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="namespace", default=None
                    ),
                ),
                ("resource", sgqlc.types.Arg(String, graphql_name="resource", default=None)),
                ("warehouse", sgqlc.types.Arg(String, graphql_name="warehouse", default=None)),
            )
        ),
    )
    """Create or update a Monte Carlo Config Template

    Arguments:

    * `config_template_json` (`String!`): Monte Carlo Template in JSON
      format
    * `create_non_ingested_tables` (`Boolean`): Create non-existent
      tables
    * `dry_run` (`Boolean`): Dry run?
    * `misconfigured_as_warning` (`Boolean`): Misconfigured errors as
      warnings
    * `namespace` (`String!`): Namespace of config template
    * `resource` (`String`): Default resource (warehouse) ID or name.
      DEPRECATED: use warehouse instead.
    * `warehouse` (`String`): Default warehouse ID or name
    """

    create_or_update_monte_carlo_config_template_async = sgqlc.types.Field(
        CreateOrUpdateMonteCarloConfigTemplateAsync,
        graphql_name="createOrUpdateMonteCarloConfigTemplateAsync",
        args=sgqlc.types.ArgDict(
            (
                (
                    "config_template_json",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="configTemplateJson",
                        default=None,
                    ),
                ),
                (
                    "create_non_ingested_tables",
                    sgqlc.types.Arg(Boolean, graphql_name="createNonIngestedTables", default=None),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=None)),
                (
                    "misconfigured_as_warning",
                    sgqlc.types.Arg(Boolean, graphql_name="misconfiguredAsWarning", default=None),
                ),
                (
                    "namespace",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="namespace", default=None
                    ),
                ),
                ("resource", sgqlc.types.Arg(String, graphql_name="resource", default=None)),
                ("warehouse", sgqlc.types.Arg(String, graphql_name="warehouse", default=None)),
            )
        ),
    )
    """Create or update a Monte Carlo Config Template asynchronously

    Arguments:

    * `config_template_json` (`String!`): Monte Carlo Template in JSON
      format
    * `create_non_ingested_tables` (`Boolean`): Create non-existent
      tables
    * `dry_run` (`Boolean`): Dry run?
    * `misconfigured_as_warning` (`Boolean`): Misconfigured errors as
      warnings
    * `namespace` (`String!`): Namespace of config template
    * `resource` (`String`): Default resource (warehouse) ID or name.
      DEPRECATED: use warehouse instead.
    * `warehouse` (`String`): Default warehouse ID or name
    """

    delete_monte_carlo_config_template = sgqlc.types.Field(
        DeleteMonteCarloConfigTemplate,
        graphql_name="deleteMonteCarloConfigTemplate",
        args=sgqlc.types.ArgDict(
            (
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=None)),
                (
                    "namespace",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="namespace", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a Monte Carlo Config Template

    Arguments:

    * `dry_run` (`Boolean`): Dry run?
    * `namespace` (`String!`): Namespace of config template
    """

    convert_ui_monitors_to_config_template = sgqlc.types.Field(
        ConvertUiMonitorsToConfigTemplate,
        graphql_name="convertUiMonitorsToConfigTemplate",
        args=sgqlc.types.ArgDict(
            (
                (
                    "all_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="allMonitors", default=False),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="monitorUuids", default=None
                    ),
                ),
                (
                    "namespace",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="namespace", default=None
                    ),
                ),
            )
        ),
    )
    """Convert a set of monitors to a config template

    Arguments:

    * `all_monitors` (`Boolean`): Convert all UI monitors (default:
      `false`)
    * `dry_run` (`Boolean`): Dry run? (default: `false`)
    * `monitor_uuids` (`[UUID]`): Monitor IDs to convert
    * `namespace` (`String!`): Namespace of config template
    """

    convert_config_template_to_ui_monitors = sgqlc.types.Field(
        ConvertConfigTemplateToUiMonitors,
        graphql_name="convertConfigTemplateToUiMonitors",
        args=sgqlc.types.ArgDict(
            (
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "namespace",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="namespace", default=None
                    ),
                ),
            )
        ),
    )
    """Convert a config template to UI Monitors

    Arguments:

    * `dry_run` (`Boolean`): Dry run? (default: `false`)
    * `namespace` (`String!`): Namespace of config template
    """

    set_sensitivity = sgqlc.types.Field(
        "SetSensitivity",
        graphql_name="setSensitivity",
        args=sgqlc.types.ArgDict(
            (
                ("event_type", sgqlc.types.Arg(String, graphql_name="eventType", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("monitor_uuid", sgqlc.types.Arg(UUID, graphql_name="monitorUuid", default=None)),
                (
                    "threshold",
                    sgqlc.types.Arg(SensitivityInput, graphql_name="threshold", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `event_type` (`String`): event type for which to get/set
      sensitivity
    * `mcon` (`String`): MCON of the object (e.g. table) for which to
      get/set sensitivity
    * `monitor_uuid` (`UUID`): UUID of an associated monitor
    * `threshold` (`SensitivityInput`): Custom threshold definition
    """

    add_to_collection_block_list = sgqlc.types.Field(
        AddToCollectionBlockList,
        graphql_name="addToCollectionBlockList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "collection_blocks",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CollectionBlockInput)),
                        graphql_name="collectionBlocks",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Adds to the list of entities for which metadata collection is not
    allowed on this account.

    Arguments:

    * `collection_blocks` (`[CollectionBlockInput]!`): The entries to
      be added to the collection block list.
    """

    remove_from_collection_block_list = sgqlc.types.Field(
        "RemoveFromCollectionBlockList",
        graphql_name="removeFromCollectionBlockList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "collection_blocks",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CollectionBlockInput)),
                        graphql_name="collectionBlocks",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Removes from the list of entities for which metadata collection is
    not allowed on this account.

    Arguments:

    * `collection_blocks` (`[CollectionBlockInput]!`): The entries to
      be removed from the collection block list.
    """

    modify_collection_block_list = sgqlc.types.Field(
        sgqlc.types.list_of("CollectionBlock"),
        graphql_name="modifyCollectionBlockList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "collection_blocks",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(ModifyCollectionBlockListInput)),
                        graphql_name="collectionBlocks",
                        default=None,
                    ),
                ),
                (
                    "parent_scope",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CollectionBlockListParentScopeInput),
                        graphql_name="parentScope",
                        default=None,
                    ),
                ),
                (
                    "target_object_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CollectionPreferenceTargetObjectType),
                        graphql_name="targetObjectType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """For an object type under a parent scope, modify the list of rules
    used to determine which objects are excluded from metadata
    collection. **Example:** To exclude ingestion for the 'analytics'
    project and all projects that start with 'prod_', make a request
    with these variables: {             "parentScope": {
    "resourceId": "9ed28eb2-6d21-4ad3-9d87-c05a3cb0f7e2"
    },             "targetObjectType": "project",
    "collectionBlocks": [                 {
    "resourceId": "9ed28eb2-6d21-4ad3-9d87-c05a3cb0f7e2",
    "project": "analytics",                     "matchType":
    "exact_match"                 },                 {
    "resourceId": "9ed28eb2-6d21-4ad3-9d87-c05a3cb0f7e2",
    "project": "prod_",                     "matchType": "prefix"
    }             ]         }

    Arguments:

    * `collection_blocks` (`[ModifyCollectionBlockListInput]!`): The
      complete list of rules for deciding which objects are excluded
      from metadata collection
    * `parent_scope` (`CollectionBlockListParentScopeInput!`): The
      direct parent scope of target objects
    * `target_object_type` (`CollectionPreferenceTargetObjectType!`):
      The type of object to apply the rules to
    """

    add_allow_list_entry = sgqlc.types.Field(
        AddAllowListEntry,
        graphql_name="addAllowListEntry",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dataset", default=None
                    ),
                ),
                (
                    "project_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="projectName", default=None
                    ),
                ),
                (
                    "resource_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Adds a project/dataset pair to the allow
    list.

    Arguments:

    * `dataset` (`String!`): The dataset to add to the allow list.
    * `project_name` (`String!`): The project_name to which to add the
      entry.
    * `resource_uuid` (`UUID!`): The resource UUID to which to add the
      entry.
    """

    delete_allow_list_entry = sgqlc.types.Field(
        DeleteAllowListEntry,
        graphql_name="deleteAllowListEntry",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dataset", default=None
                    ),
                ),
                (
                    "project_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="projectName", default=None
                    ),
                ),
                (
                    "resource_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Deletes a project/dataset pair from the
    allow list.

    Arguments:

    * `dataset` (`String!`): The dataset to delete from the allow
      list.
    * `project_name` (`String!`): The project_name from which to
      delete the entry.
    * `resource_uuid` (`UUID!`): The resource UUID from which to
      delete the entry.
    """

    set_workspaces_allow_list_for_power_bi_reports_collection = sgqlc.types.Field(
        "SetWorkspacesAllowListForPowerBiReportsCollection",
        graphql_name="setWorkspacesAllowListForPowerBiReportsCollection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "allowed_workspaces",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="allowedWorkspaces",
                        default=None,
                    ),
                ),
                (
                    "connection_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Sets the list of workspaces to allow for
    collection in BI Reports.

    Arguments:

    * `allowed_workspaces` (`[String]!`): The entries to be added to
      the filter list.
    * `connection_uuid` (`UUID!`): The UUID of the connection that
      handles the Power BI Reports collection.
    """

    set_asset_collection_preferences = sgqlc.types.Field(
        "SetAssetCollectionPreferences",
        graphql_name="setAssetCollectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                (
                    "asset_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="assetType", default=None
                    ),
                ),
                (
                    "default_effect",
                    sgqlc.types.Arg(
                        AssetCollectionRuleEffect, graphql_name="defaultEffect", default="allow"
                    ),
                ),
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
                (
                    "rules",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(AssetCollectionRuleInput),
                        graphql_name="rules",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Sets rules for collection of a particular asset
    type.

    Arguments:

    * `asset_type` (`String!`): The asset type that these collection
      preferences will apply to (e.g. 'workbook', 'project' etc.)
    * `default_effect` (`AssetCollectionRuleEffect`): Whether to allow
      or block assets of this type when no rules match. (default:
      `"allow"`)
    * `resource_id` (`UUID!`): The resource UUID that these collection
      preferences will apply to.
    * `rules` (`[AssetCollectionRuleInput]`): The set of rules for
      collection of this asset type.
    """

    delete_asset_collection_preferences = sgqlc.types.Field(
        DeleteAssetCollectionPreferences,
        graphql_name="deleteAssetCollectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                (
                    "asset_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="assetType", default=None
                    ),
                ),
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Deletes rules for collection of a particular asset
    type.

    Arguments:

    * `asset_type` (`String!`): The asset type of the preferences to
      delete.
    * `resource_id` (`UUID!`): The resource UUID of the preferences to
      delete.
    """

    delete_data_maintenance_entry = sgqlc.types.Field(
        DeleteDataMaintenanceEntry,
        graphql_name="deleteDataMaintenanceEntry",
        args=sgqlc.types.ArgDict(
            (("id", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="id", default=None)),)
        ),
    )
    """Delete a data maintenance window

    Arguments:

    * `id` (`Int!`): ID of existing data maintenance entry for
      deleting
    """

    create_or_update_data_maintenance_entry = sgqlc.types.Field(
        CreateOrUpdateDataMaintenanceEntry,
        graphql_name="createOrUpdateDataMaintenanceEntry",
        args=sgqlc.types.ArgDict(
            (
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                ("id", sgqlc.types.Arg(Int, graphql_name="id", default=None)),
                (
                    "maintenance_type",
                    sgqlc.types.Arg(
                        DataMaintenanceMetric, graphql_name="maintenanceType", default=None
                    ),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("monitor_id", sgqlc.types.Arg(UUID, graphql_name="monitorId", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                ("reason", sgqlc.types.Arg(String, graphql_name="reason", default=None)),
                (
                    "reason_type",
                    sgqlc.types.Arg(
                        DataMaintenanceReasonType, graphql_name="reasonType", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "time_series_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="timeSeriesUuid", default=None),
                ),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """Creates or updates a data maintenance period

    Arguments:

    * `dataset` (`String`): Deprecated: Name of dataset to to set
      maintenance period for. If `dataset` is given, `project` is
      required as-well. Use 'mcon' instead.
    * `dw_id` (`UUID`): Warehouse UUID. Required if no monitor_id is
      given
    * `end_time` (`DateTime`): Start period of data maintenance. If
      not set, all future data will be ignored until updated
    * `field` (`String`): Field to set maintenance period for. If set,
      the maintenance windows will only apply to the given field. Used
      for Monitor related windows only. Deprecated: Use
      time_series_uuid instead
    * `id` (`Int`): ID of existing data maintenance entry for updating
    * `maintenance_type` (`DataMaintenanceMetric`): If not set, all
      metrics for the object will be ignored
    * `mcon` (`String`): MCON unique identifier of object to set
      maintenance period for. MCON can be of type 'warehouse',
      'project', 'dataset' or any table type. Setting any type other
      than a table type will set the maintenance window for all
      matching tables.
    * `metric` (`String`): Metric to set maintenance period for. If
      set, the maintenance windows will only apply to the given
      metric. Used for Monitor related windows only. Deprecated: Use
      time_series_uuid instead
    * `monitor_id` (`UUID`): Monitor ID to set maintenance period for.
      If set, the maintenance windows will only apply to the given
      monitor.
    * `project` (`String`): Deprecated: Name of database or project to
      to set maintenance period for. Use 'mcon' instead.
    * `reason` (`String`): Description of the reason for the
      maintenance window
    * `reason_type` (`DataMaintenanceReasonType`): Reason type for the
      maintenance window
    * `start_time` (`DateTime`): Start period of data maintenance. If
      not set, all previous data will be ignored.
    * `time_series_uuid` (`UUID`): Time series UUID to set maintenance
      period for. If set, the maintenance windows will only apply to
      the given time series. Used for Monitor related windows only.
    * `where_condition` (`String`): Where condition to set maintenance
      period for. If set, the maintenance windows will only apply to
      the given where condition. Used for Monitor related windows
      only. Deprecated: Use time_series_uuid instead
    """

    create_data_maintenance_window_from_holidays = sgqlc.types.Field(
        CreateDataMaintenanceWindowFromHolidays,
        graphql_name="createDataMaintenanceWindowFromHolidays",
        args=sgqlc.types.ArgDict(
            (
                (
                    "country_or_market_code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="countryOrMarketCode",
                        default=None,
                    ),
                ),
                (
                    "end",
                    sgqlc.types.Arg(sgqlc.types.non_null(Date), graphql_name="end", default=None),
                ),
                (
                    "holidays",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="holidays",
                        default=None,
                    ),
                ),
                (
                    "maintenance_type",
                    sgqlc.types.Arg(
                        DataMaintenanceMetric, graphql_name="maintenanceType", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "start",
                    sgqlc.types.Arg(sgqlc.types.non_null(Date), graphql_name="start", default=None),
                ),
                (
                    "timezone",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="timezone", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create a maintenance window based over a list of
    holidays

    Arguments:

    * `country_or_market_code` (`String!`): Country or market code for
      which to create holiday maintenance windows
    * `end` (`Date!`): Date until to create maintenance windows for
    * `holidays` (`[String]!`): List of holiday names to create
      maintenance window for
    * `maintenance_type` (`DataMaintenanceMetric`): If not set, all
      metrics for the object will be ignored
    * `mcon` (`String!`): MCON unique identifier of object to set
      maintenance period for. MCON can be of type 'warehouse',
      'project', 'dataset' or any table type. Setting any type other
      than a table type will set the maintenance window for all
      matching tables.
    * `start` (`Date!`): Date from when to create maintenance windows
      for
    * `timezone` (`String!`): Timezone to create maintenance windows
      for
    """

    create_custom_rule = sgqlc.types.Field(
        CreateCustomRule,
        graphql_name="createCustomRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
            )
        ),
    )
    """Deprecated, use CreateOrUpdateCustomRule instead

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String`): Used as the name in the UI
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID`): Warehouse the tables are contained in.
      Required when using fullTableIds
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `schedule_config` (`ScheduleConfigInput`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    """

    create_or_update_custom_rule = sgqlc.types.Field(
        CreateOrUpdateCustomRule,
        graphql_name="createOrUpdateCustomRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
            )
        ),
    )
    """DEPRECATED. Depending on the type of monitor you would like to
    create, use CreateOrUpdateVolumeRule,
    CreateOrUpdateFreshnessCustomRule, CreateOrUpdateCustomSqlRule,
    CreateOrUpdateComparisonRule or CreateOrUpdateQueryPerfRule
    instead.

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String`): Used as the name in the UI
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID`): Warehouse the tables are contained in.
      Required when using fullTableIds
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `schedule_config` (`ScheduleConfigInput`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    """

    create_custom_metric_rule = sgqlc.types.Field(
        CreateCustomMetricRule,
        graphql_name="createCustomMetricRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "custom_sampling_sql",
                    sgqlc.types.Arg(String, graphql_name="customSamplingSql", default=None),
                ),
                (
                    "custom_sql",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="customSql", default=None
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "field_metric",
                    sgqlc.types.Arg(FieldMetricInput, graphql_name="fieldMetric", default=None),
                ),
                (
                    "field_query_parameters",
                    sgqlc.types.Arg(
                        FieldQueryParametersInput, graphql_name="fieldQueryParameters", default=None
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(QueryResultType, graphql_name="queryResultType", default=None),
                ),
                (
                    "query_template_id",
                    sgqlc.types.Arg(String, graphql_name="queryTemplateId", default=None),
                ),
                (
                    "query_template_variable_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(QueryTemplateVariableValueInput)),
                        graphql_name="queryTemplateVariableValues",
                        default=None,
                    ),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
                (
                    "variable_definitions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(VariableDefinitionInput)),
                        graphql_name="variableDefinitions",
                        default=None,
                    ),
                ),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
            )
        ),
    )
    """Deprecated, use CreateOrUpdateCustomMetricRule instead

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `custom_sampling_sql` (`String`): Custom sampling SQL query to
      run on breach
    * `custom_sql` (`String!`): Custom SQL query to run
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID!`): Warehouse UUID
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `field_metric` (`FieldMetricInput`): (DEPRECATED). Use standard
      Custom SQL monitors instead.
    * `field_query_parameters` (`FieldQueryParametersInput`):
      (DEPRECATED). Use Validation monitors instead for cardinality
      checks.
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `query_result_type` (`QueryResultType`): How the query result is
      used for the metric. Uses row count if unset.
    * `query_template_id` (`String`): (DEPRECATED). Use Validation
      monitors instead for referential integrity checks.
    * `query_template_variable_values`
      (`[QueryTemplateVariableValueInput!]`): (DEPRECATED). Use
      Validation monitors instead for referential integrity checks.
    * `schedule_config` (`ScheduleConfigInput`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timeout` (`Int`): Timeout for the SQL query
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    * `variable_definitions` (`[VariableDefinitionInput!]`): Possible
      variable values for SQL query. Allows specifying runtime
      variables as well.
    * `variables` (`JSONString`): Possible variable values for SQL
      query. Only to specify static variables.
    """

    create_or_update_custom_metric_rule = sgqlc.types.Field(
        CreateOrUpdateCustomMetricRule,
        graphql_name="createOrUpdateCustomMetricRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "custom_sampling_sql",
                    sgqlc.types.Arg(String, graphql_name="customSamplingSql", default=None),
                ),
                (
                    "custom_sql",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="customSql", default=None
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "field_metric",
                    sgqlc.types.Arg(FieldMetricInput, graphql_name="fieldMetric", default=None),
                ),
                (
                    "field_query_parameters",
                    sgqlc.types.Arg(
                        FieldQueryParametersInput, graphql_name="fieldQueryParameters", default=None
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(QueryResultType, graphql_name="queryResultType", default=None),
                ),
                (
                    "query_template_id",
                    sgqlc.types.Arg(String, graphql_name="queryTemplateId", default=None),
                ),
                (
                    "query_template_variable_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(QueryTemplateVariableValueInput)),
                        graphql_name="queryTemplateVariableValues",
                        default=None,
                    ),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
                (
                    "variable_definitions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(VariableDefinitionInput)),
                        graphql_name="variableDefinitions",
                        default=None,
                    ),
                ),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
            )
        ),
    )
    """Create or update a custom metric rule

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `custom_sampling_sql` (`String`): Custom sampling SQL query to
      run on breach
    * `custom_sql` (`String!`): Custom SQL query to run
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID!`): Warehouse UUID
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `field_metric` (`FieldMetricInput`): (DEPRECATED). Use standard
      Custom SQL monitors instead.
    * `field_query_parameters` (`FieldQueryParametersInput`):
      (DEPRECATED). Use Validation monitors instead for cardinality
      checks.
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `query_result_type` (`QueryResultType`): How the query result is
      used for the metric. Uses row count if unset.
    * `query_template_id` (`String`): (DEPRECATED). Use Validation
      monitors instead for referential integrity checks.
    * `query_template_variable_values`
      (`[QueryTemplateVariableValueInput!]`): (DEPRECATED). Use
      Validation monitors instead for referential integrity checks.
    * `schedule_config` (`ScheduleConfigInput`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timeout` (`Int`): Timeout for the SQL query
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    * `variable_definitions` (`[VariableDefinitionInput!]`): Possible
      variable values for SQL query. Allows specifying runtime
      variables as well.
    * `variables` (`JSONString`): Possible variable values for SQL
      query. Only to specify static variables.
    """

    update_custom_metric_rule_notes = sgqlc.types.Field(
        "UpdateCustomMetricRuleNotes",
        graphql_name="updateCustomMetricRuleNotes",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="customRuleUuid", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default=None)),
            )
        ),
    )
    """Create or update notes for custom metric rule

    Arguments:

    * `custom_rule_uuid` (`UUID!`): UUID of custom rule, to update
      existing rule
    * `notes` (`String`): Additional context for the custom SQL rule
    """

    update_custom_metric_severity = sgqlc.types.Field(
        "UpdateCustomMetricSeverity",
        graphql_name="updateCustomMetricSeverity",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="customRuleUuid", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default=None)),
            )
        ),
    )
    """DEPRECATED. Create or update default severity for custom metric
    rule

    Arguments:

    * `custom_rule_uuid` (`UUID!`): UUID of custom rule, to update
      existing rule
    * `severity` (`String`): System set severity when an incident for
      the rule is created
    """

    trigger_circuit_breaker_rule = sgqlc.types.Field(
        "TriggerCircuitBreakerRule",
        graphql_name="triggerCircuitBreakerRule",
        args=sgqlc.types.ArgDict(
            (
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
                ("rule_name", sgqlc.types.Arg(String, graphql_name="ruleName", default=None)),
                ("rule_uuid", sgqlc.types.Arg(UUID, graphql_name="ruleUuid", default=None)),
            )
        ),
    )
    """Run a custom rule as a circuit breaker immediately. Supports rules
    that create a single query.

    Arguments:

    * `namespace` (`String`): Namespace
    * `rule_name` (`String`): Rule Name
    * `rule_uuid` (`UUID`): Rule UUID
    """

    trigger_custom_rule = sgqlc.types.Field(
        "TriggerCustomRule",
        graphql_name="triggerCustomRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_sql_contains",
                    sgqlc.types.Arg(String, graphql_name="customSqlContains", default=None),
                ),
                (
                    "description_contains",
                    sgqlc.types.Arg(String, graphql_name="descriptionContains", default=None),
                ),
                ("rule_id", sgqlc.types.Arg(UUID, graphql_name="ruleId", default=None)),
            )
        ),
    )
    """Run a custom rule immediately

    Arguments:

    * `custom_sql_contains` (`String`): String to completely or
      partially match the rule SQL, case-insensitive
    * `description_contains` (`String`): String to completely or
      partially match the rule description, case-insensitive
    * `rule_id` (`UUID`): Rule id
    """

    create_or_update_volume_rule = sgqlc.types.Field(
        CreateOrUpdateVolumeRule,
        graphql_name="createOrUpdateVolumeRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_collection_schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput,
                        graphql_name="dataCollectionScheduleConfig",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("override", sgqlc.types.Arg(Boolean, graphql_name="override", default=None)),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "replaces_ootb",
                    sgqlc.types.Arg(Boolean, graphql_name="replacesOotb", default=None),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
            )
        ),
    )
    """(experimental) Create or update a volume monitor

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_collection_schedule_config` (`ScheduleConfigInput`): Data
      Collection schedule of custom rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID`): Warehouse the tables are contained in.
      Required when using fullTableIds
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `override` (`Boolean`): If override is set, it forces the dc
      schedule to run
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `replaces_ootb` (`Boolean`): Indicate if this rule replaces the
      default ootb detector
    * `schedule_config` (`ScheduleConfigInput`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    """

    create_or_update_custom_sql_rule = sgqlc.types.Field(
        CreateOrUpdateCustomSqlRule,
        graphql_name="createOrUpdateCustomSqlRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_condition",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CustomSqlRuleAlertConditionInput),
                        graphql_name="alertCondition",
                        default=None,
                    ),
                ),
                (
                    "audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="audiences",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "custom_sampling_sql",
                    sgqlc.types.Arg(String, graphql_name="customSamplingSql", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(QueryResultType, graphql_name="queryResultType", default=None),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                (
                    "sql",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="sql", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "variable_definitions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(VariableDefinitionInput)),
                        graphql_name="variableDefinitions",
                        default=None,
                    ),
                ),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
            )
        ),
    )
    """(experimental) Create or update a custom SQL monitor

    Arguments:

    * `alert_condition` (`CustomSqlRuleAlertConditionInput!`): Alert
      condition.
    * `audiences` (`[String!]`): The monitor audiences
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `custom_sampling_sql` (`String`): Custom sampling SQL query to
      run on breach
    * `data_quality_dimension` (`String`): Data quality dimension of
      the monitor.
    * `description` (`String!`): Used as the name in the UI
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `dw_id` (`UUID!`): Warehouse UUID
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The monitor audiences to
      notify on failure
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `query_result_type` (`QueryResultType`): How the query result is
      used for the metric. Uses row count if unset.
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of custom
      rule
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `sql` (`String!`): Custom SQL query to run
    * `tags` (`[TagKeyValuePairInput!]`): The monitor tags.
    * `timeout` (`Int`): Timeout for the SQL query
    * `uuid` (`UUID`): UUID of the rule, to update an existing rule
    * `variable_definitions` (`[VariableDefinitionInput!]`): Possible
      variable values for SQL query. Allows specifying runtime
      variables as well.
    * `variables` (`JSONString`): Possible variable values for SQL
      query
    """

    create_or_update_comparison_rule = sgqlc.types.Field(
        CreateOrUpdateComparisonRule,
        graphql_name="createOrUpdateComparisonRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryResultType),
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                (
                    "source_connection_id",
                    sgqlc.types.Arg(UUID, graphql_name="sourceConnectionId", default=None),
                ),
                (
                    "source_dw_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="sourceDwId", default=None
                    ),
                ),
                (
                    "source_sql_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="sourceSqlQuery", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "target_connection_id",
                    sgqlc.types.Arg(UUID, graphql_name="targetConnectionId", default=None),
                ),
                (
                    "target_dw_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="targetDwId", default=None
                    ),
                ),
                (
                    "target_sql_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="targetSqlQuery", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update a comparison monitor

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `query_result_type` (`QueryResultType!`): Specifies query result
      format for generating metrics
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `source_connection_id` (`UUID`): Connection (i.e. query-engine)
      to use for source query
    * `source_dw_id` (`UUID!`): Warehouse UUID for source query
    * `source_sql_query` (`String!`): Query to generate source metric
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `target_connection_id` (`UUID`): Connection (i.e. query-engine)
      to use for target query
    * `target_dw_id` (`UUID!`): Warehouse UUID for target query
    * `target_sql_query` (`String!`): Query to generate target metric
    """

    create_or_update_query_perf_rule = sgqlc.types.Field(
        CreateOrUpdateQueryPerfRule,
        graphql_name="createOrUpdateQueryPerfRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default=None)),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                ("rule_name", sgqlc.types.Arg(String, graphql_name="ruleName", default=None)),
                (
                    "selection",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QuerySelectionInput),
                        graphql_name="selection",
                        default=None,
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update a query performance monitor

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): data quality dimension
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `failure_audiences` (`[String!]`): The monitor failure audiences
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the rule
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `rule_name` (`String`): Rule Name. DEPRECATED: field will be
      ignored.
    * `selection` (`QuerySelectionInput!`): Selection of the monitored
      queries
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    """

    create_or_update_freshness_custom_rule = sgqlc.types.Field(
        CreateOrUpdateFreshnessCustomRule,
        graphql_name="createOrUpdateFreshnessCustomRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("pause", sgqlc.types.Arg(Boolean, graphql_name="pause", default=None)),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "replaces_ootb",
                    sgqlc.types.Arg(Boolean, graphql_name="replacesOotb", default=None),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
            )
        ),
    )
    """(experimental) Create or update a freshness monitor

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String`): Used as the name in the UI
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID`): Warehouse the tables are contained in.
      Required when using fullTableIds
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `labels` (`[String]`): The monitor labels
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `pause` (`Boolean`): Pause state of the rule.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `replaces_ootb` (`Boolean`): Indicate if this rule replaces the
      default ootb detector
    * `schedule_config` (`ScheduleConfigInput`): Schedule of custom
      rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    """

    snooze_custom_rule = sgqlc.types.Field(
        "SnoozeCustomRule",
        graphql_name="snoozeCustomRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "snooze_minutes",
                    sgqlc.types.Arg(Int, graphql_name="snoozeMinutes", default=None),
                ),
                (
                    "snooze_type",
                    sgqlc.types.Arg(CustomRuleSnoozeInput, graphql_name="snoozeType", default=None),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Snooze a custom rule. Data collection will continue, but no
    anomalies will be reported.

    Arguments:

    * `snooze_minutes` (`Int`): Number of minutes to snooze rule -
      deprecated by snooze_type
    * `snooze_type` (`CustomRuleSnoozeInput`): Choose regular snooze
      or conditional snooze options
    * `uuid` (`UUID`): UUID for rule to snooze - deprecated by
      snooze_type
    """

    unsnooze_custom_rule = sgqlc.types.Field(
        "UnsnoozeCustomRule",
        graphql_name="unsnoozeCustomRule",
        args=sgqlc.types.ArgDict(
            (("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),)
        ),
    )
    """Un-snooze a custom rule.

    Arguments:

    * `uuid` (`UUID`): UUID for rule to un-snooze
    """

    snooze_custom_rules = sgqlc.types.Field(
        "SnoozeCustomRules",
        graphql_name="snoozeCustomRules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "conditional_snooze",
                    sgqlc.types.Arg(Boolean, graphql_name="conditionalSnooze", default=False),
                ),
                (
                    "snooze_minutes",
                    sgqlc.types.Arg(Int, graphql_name="snoozeMinutes", default=None),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Snooze a list of custom rules. Data collection will
    continue, but no anomalies will be reported.

    Arguments:

    * `conditional_snooze` (`Boolean`): snooze rules until breach
      condition changes or is resolved (default: `false`)
    * `snooze_minutes` (`Int`): number of minutes to snooze rules
    * `uuids` (`[UUID!]`): UUIDs of the rules to snooze
    """

    unsnooze_custom_rules = sgqlc.types.Field(
        "UnsnoozeCustomRules",
        graphql_name="unsnoozeCustomRules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Un-snooze a list of custom rules.

    Arguments:

    * `uuids` (`[UUID!]`): UUIDs of the rules to snooze
    """

    delete_custom_rule = sgqlc.types.Field(
        DeleteCustomRule,
        graphql_name="deleteCustomRule",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
            )
        ),
    )
    """Delete a custom rule

    Arguments:

    * `uuid` (`UUID`): UUID for rule to delete
    * `warehouse_uuid` (`UUID`): Deprecated
    """

    restore_custom_rule = sgqlc.types.Field(
        "RestoreCustomRule",
        graphql_name="restoreCustomRule",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
            )
        ),
    )
    """Restore a custom rule

    Arguments:

    * `uuid` (`UUID`): UUID for rule to restore
    * `warehouse_uuid` (`UUID`): Deprecated
    """

    trigger_circuit_breaker_rule_v2 = sgqlc.types.Field(
        "TriggerCircuitBreakerRuleV2",
        graphql_name="triggerCircuitBreakerRuleV2",
        args=sgqlc.types.ArgDict(
            (
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
                ("rule_name", sgqlc.types.Arg(String, graphql_name="ruleName", default=None)),
                ("rule_uuid", sgqlc.types.Arg(UUID, graphql_name="ruleUuid", default=None)),
                (
                    "runtime_variables",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(RuntimeVariableValueInput)),
                        graphql_name="runtimeVariables",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Run a custom rule as a circuit breaker immediately. Supports rules
    that create multiple queries.

    Arguments:

    * `namespace` (`String`): Namespace
    * `rule_name` (`String`): Rule Name
    * `rule_uuid` (`UUID`): Rule UUID
    * `runtime_variables` (`[RuntimeVariableValueInput!]`): Rule
      execution runtime variables
    """

    run_sql_rule = sgqlc.types.Field(
        "RunSqlRule",
        graphql_name="runSqlRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "rule_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="ruleUuid", default=None
                    ),
                ),
                (
                    "runtime_variables",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(RuntimeVariableValueInput)),
                        graphql_name="runtimeVariables",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Run a Custom SQL monitor manually

    Arguments:

    * `rule_uuid` (`UUID!`): Rule UUID
    * `runtime_variables` (`[RuntimeVariableValueInput!]`): Rule
      execution runtime_variables
    """

    run_custom_rules = sgqlc.types.Field(
        "RunCustomRules",
        graphql_name="runCustomRules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "rule_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="ruleUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Run a list of custom rules manually

    Arguments:

    * `rule_uuids` (`[UUID!]!`): Rule UUIDs
    """

    pause_rule = sgqlc.types.Field(
        "PauseRule",
        graphql_name="pauseRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "pause",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="pause", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Pause a rule from collecting data or triggering notifications

    Arguments:

    * `pause` (`Boolean!`): Pause state of the monitor.
    * `uuid` (`UUID!`): UUID of the rule whose skip status is being
      changed.
    """

    update_custom_rule_investigation_query = sgqlc.types.Field(
        "UpdateCustomRuleInvestigationQuery",
        graphql_name="updateCustomRuleInvestigationQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_sampling_sql",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="customSamplingSql", default=None
                    ),
                ),
                (
                    "rule_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="ruleUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Update a rule's investigation query

    Arguments:

    * `custom_sampling_sql` (`String!`): The new investigation query
    * `rule_uuid` (`UUID!`): The UUID of the rule to update
    """

    create_or_update_lineage_node = sgqlc.types.Field(
        CreateOrUpdateLineageNode,
        graphql_name="createOrUpdateLineageNode",
        args=sgqlc.types.ArgDict(
            (
                ("expire_at", sgqlc.types.Arg(DateTime, graphql_name="expireAt", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                (
                    "object_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="objectId", default=None
                    ),
                ),
                (
                    "object_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="objectType", default=None
                    ),
                ),
                (
                    "properties",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ObjectPropertyInput),
                        graphql_name="properties",
                        default=None,
                    ),
                ),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
            )
        ),
    )
    """Create or update a lineage node

    Arguments:

    * `expire_at` (`DateTime`): When the node will expire. If not
      provided, the node will expire 7 days from creation.
    * `name` (`String`): Object name (table name, report name, etc)
    * `object_id` (`String!`): Object identifier
    * `object_type` (`String!`): Object type
    * `properties` (`[ObjectPropertyInput]`): A list of object
      properties to be indexed by the search service
    * `resource_id` (`UUID`): The id of the resource containing the
      node
    * `resource_name` (`String`): The name of the resource containing
      the node
    """

    create_or_update_lineage_edge = sgqlc.types.Field(
        CreateOrUpdateLineageEdge,
        graphql_name="createOrUpdateLineageEdge",
        args=sgqlc.types.ArgDict(
            (
                (
                    "destination",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(NodeInput), graphql_name="destination", default=None
                    ),
                ),
                (
                    "edge_type",
                    sgqlc.types.Arg(EdgeType, graphql_name="edgeType", default="IS_DOWNSTREAM"),
                ),
                ("expire_at", sgqlc.types.Arg(DateTime, graphql_name="expireAt", default=None)),
                (
                    "source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(NodeInput), graphql_name="source", default=None
                    ),
                ),
            )
        ),
    )
    """Create or update a lineage edge

    Arguments:

    * `destination` (`NodeInput!`): The destination node
    * `edge_type` (`EdgeType`): The type of edge to create or update.
      Must be one of IS_DOWNSTREAM, MODIFIES, IS_READ_BY (default:
      `"IS_DOWNSTREAM"`)
    * `expire_at` (`DateTime`): When the edge will expire. If not
      provided, the node will expire 7 days from creation.
    * `source` (`NodeInput!`): The source node
    """

    create_or_update_lineage_node_block_pattern = sgqlc.types.Field(
        CreateOrUpdateLineageNodeBlockPattern,
        graphql_name="createOrUpdateLineageNodeBlockPattern",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset_regexp",
                    sgqlc.types.Arg(String, graphql_name="datasetRegexp", default=None),
                ),
                (
                    "project_regexp",
                    sgqlc.types.Arg(String, graphql_name="projectRegexp", default=None),
                ),
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
                ("table_regexp", sgqlc.types.Arg(String, graphql_name="tableRegexp", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a node block pattern

    Arguments:

    * `dataset_regexp` (`String`): Block datasets matching the regexp
    * `project_regexp` (`String`): Block projects matching the regexp
    * `resource_id` (`UUID!`): The id of the resource containing the
      node
    * `table_regexp` (`String`): Block tables matching the regexp
    * `uuid` (`UUID`): The pattern UUID (updates only)
    """

    create_or_update_lineage_node_replacement_rule = sgqlc.types.Field(
        CreateOrUpdateLineageNodeReplacementRule,
        graphql_name="createOrUpdateLineageNodeReplacementRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "case_insensitive",
                    sgqlc.types.Arg(Boolean, graphql_name="caseInsensitive", default=None),
                ),
                (
                    "pattern",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="pattern", default=None
                    ),
                ),
                (
                    "replacement",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="replacement", default=None
                    ),
                ),
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a node replacement rule

    Arguments:

    * `case_insensitive` (`Boolean`): Case sensitivity of the pattern
      matching
    * `pattern` (`String!`): Modify canonical name by replacing the
      pattern with replacement
    * `replacement` (`String!`): Modify canonical name by replacing
      the pattern with replacement
    * `resource_id` (`UUID!`): The id of the resource containing the
      node
    * `uuid` (`UUID`): The rule UUID (updates only)
    """

    create_or_update_lineage_node_collapsing_rule = sgqlc.types.Field(
        CreateOrUpdateLineageNodeCollapsingRule,
        graphql_name="createOrUpdateLineageNodeCollapsingRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "case_insensitive",
                    sgqlc.types.Arg(Boolean, graphql_name="caseInsensitive", default=False),
                ),
                (
                    "pattern",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="pattern", default=None
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a node collapsing rule

    Arguments:

    * `case_insensitive` (`Boolean`): Case sensitivity of the pattern
      matching (default: `false`)
    * `pattern` (`String!`): Nodes which canonical name matches the
      pattern will be marked as collapsible
    * `uuid` (`UUID`): The rule UUID (updates only)
    """

    delete_lineage_node = sgqlc.types.Field(
        DeleteLineageNode,
        graphql_name="deleteLineageNode",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Delete a lineage node and any lineage edges connected to it.

    Arguments:

    * `mcon` (`String!`): The MCON of the node to be deleted
    """

    delete_lineage_node_block_pattern = sgqlc.types.Field(
        DeleteLineageNodeBlockPattern,
        graphql_name="deleteLineageNodeBlockPattern",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a lineage node block pattern.

    Arguments:

    * `uuid` (`UUID!`): The UUID of the pattern to delete
    """

    delete_lineage_node_replacement_rule = sgqlc.types.Field(
        DeleteLineageNodeReplacementRule,
        graphql_name="deleteLineageNodeReplacementRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a lineage node replacement rule

    Arguments:

    * `uuid` (`UUID!`): The UUID of the replacement rule to delete
    """

    delete_lineage_node_collapsing_rule = sgqlc.types.Field(
        DeleteLineageNodeCollapsingRule,
        graphql_name="deleteLineageNodeCollapsingRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a lineage node collapsing rule

    Arguments:

    * `uuid` (`UUID!`): The UUID of the collapsing rule to delete
    """

    create_or_update_field_quality_rule = sgqlc.types.Field(
        CreateOrUpdateFieldQualityRule,
        graphql_name="createOrUpdateFieldQualityRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "event_rollup_count",
                    sgqlc.types.Arg(Int, graphql_name="eventRollupCount", default=None),
                ),
                (
                    "event_rollup_until_changed",
                    sgqlc.types.Arg(Boolean, graphql_name="eventRollupUntilChanged", default=None),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "field_names",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="fieldNames",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(FieldMetricFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
                (
                    "interval_minutes",
                    sgqlc.types.Arg(Int, graphql_name="intervalMinutes", default=None),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "metric_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(FieldMetricType),
                        graphql_name="metricType",
                        default=None,
                    ),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default="")),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="tableMcons",
                        default=None,
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
            )
        ),
    )
    """Create or update a field quality rule

    Arguments:

    * `comparisons` (`[CustomRuleComparisonInput]!`): Custom rule
      comparisons
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `custom_rule_uuid` (`UUID`): UUID of custom rule, to update
      existing rule
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `description` (`String!`): Description of rule
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dw_id` (`UUID!`): Warehouse UUID
    * `event_rollup_count` (`Int`): The number of events to roll up
      into a single incident
    * `event_rollup_until_changed` (`Boolean`): If true, roll up
      events until the value changes
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `field_names` (`[String]!`): Fields to monitor
    * `filters` (`[FieldMetricFilterInput]`): Filters for which rows
      the metric is computed over
    * `interval_minutes` (`Int`): How often to run scheduled custom
      rule check (DEPRECATED, use schedule instead)
    * `labels` (`[String]`): The monitor labels
    * `metric_type` (`FieldMetricType!`): Type of metric to compute
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of the
      field quality rule
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor (default:
      `""`)
    * `start_time` (`DateTime`): Start time of schedule (DEPRECATED,
      use schedule instead)
    * `table_mcons` (`[String]!`): MCON of tables to monitor
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `timeout` (`Int`): Timeout for the SQL query
    * `timezone` (`String`): Timezone (DEPRECATED, use timezone in
      scheduleConfig instead
    """

    create_or_update_catalog_object_metadata = sgqlc.types.Field(
        CreateOrUpdateCatalogObjectMetadata,
        graphql_name="createOrUpdateCatalogObjectMetadata",
        args=sgqlc.types.ArgDict(
            (
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Create or update an asset's metadata

    Arguments:

    * `description` (`String!`): Description of object
    * `mcon` (`String!`): Monte Carlo full identifier for an entity
    """

    delete_catalog_object_metadata = sgqlc.types.Field(
        DeleteCatalogObjectMetadata,
        graphql_name="deleteCatalogObjectMetadata",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Delete metadata for an asset

    Arguments:

    * `mcon` (`String!`): Monte Carlo full identifier for an entity
    """

    create_or_update_object_property = sgqlc.types.Field(
        CreateOrUpdateObjectProperty,
        graphql_name="createOrUpdateObjectProperty",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mconId", default=None
                    ),
                ),
                (
                    "property_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="propertyName", default=None
                    ),
                ),
                (
                    "property_source_type",
                    sgqlc.types.Arg(String, graphql_name="propertySourceType", default="dashboard"),
                ),
                (
                    "property_value",
                    sgqlc.types.Arg(String, graphql_name="propertyValue", default=None),
                ),
            )
        ),
    )
    """Create or update properties (tags) for objects (e.g. tables,
    fields, etc.)

    Arguments:

    * `mcon_id` (`String!`): Monte Carlo full identifier for an entity
    * `property_name` (`String!`): Name of the property (AKA tag key)
    * `property_source_type` (`String`): Where property originated.
      (default: `"dashboard"`)
    * `property_value` (`String`): Value of the property (AKA tag
      value)
    """

    delete_object_property = sgqlc.types.Field(
        DeleteObjectProperty,
        graphql_name="deleteObjectProperty",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mconId", default=None
                    ),
                ),
                (
                    "property_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="propertyName", default=None
                    ),
                ),
                (
                    "property_source_type",
                    sgqlc.types.Arg(String, graphql_name="propertySourceType", default="dashboard"),
                ),
            )
        ),
    )
    """Delete properties (tags) for objects (e.g. tables, fields, etc.)

    Arguments:

    * `mcon_id` (`String!`): Monte Carlo full identifier for an entity
    * `property_name` (`String!`): Name of the property (AKA tag key)
    * `property_source_type` (`String`): Where property originated.
      (default: `"dashboard"`)
    """

    bulk_create_or_update_object_properties = sgqlc.types.Field(
        BulkCreateOrUpdateObjectProperties,
        graphql_name="bulkCreateOrUpdateObjectProperties",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input_object_properties",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(InputObjectProperty)),
                        graphql_name="inputObjectProperties",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Create or update a list of properties (tags) for objects (e.g.
    tables, fields, etc.)

    Arguments:

    * `input_object_properties` (`[InputObjectProperty]!`): List of
      object properties to create and update
    """

    create_or_update_monitor_label = sgqlc.types.Field(
        CreateOrUpdateMonitorLabel,
        graphql_name="createOrUpdateMonitorLabel",
        args=sgqlc.types.ArgDict(
            (
                (
                    "label",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="label", default=None
                    ),
                ),
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="monitorUuids", default=None
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a monitor label

    Arguments:

    * `label` (`String!`): The monitor label name
    * `monitor_uuids` (`[UUID]`): If any monitor IDs are given, add
      this label to those monitors; additive only, does not remove the
      label from other monitors
    * `uuid` (`UUID`): The monitor label ID
    """

    delete_monitor_label = sgqlc.types.Field(
        DeleteMonitorLabel,
        graphql_name="deleteMonitorLabel",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a monitor label

    Arguments:

    * `uuid` (`UUID!`): The monitor label ID
    """

    add_monitors_labels = sgqlc.types.Field(
        AddMonitorsLabels,
        graphql_name="addMonitorsLabels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="labels",
                        default=None,
                    ),
                ),
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `labels` (`[String]!`): Labels to add on the monitors
    * `monitor_uuids` (`[UUID]!`): UUID of the monitors to update
    """

    remove_monitors_labels = sgqlc.types.Field(
        "RemoveMonitorsLabels",
        graphql_name="removeMonitorsLabels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="labels",
                        default=None,
                    ),
                ),
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `labels` (`[String]!`): Labels to remove from the monitors
    * `monitor_uuids` (`[UUID]!`): UUID of the monitors to update
    """

    create_or_update_custom_sql_template = sgqlc.types.Field(
        CreateOrUpdateCustomSQLTemplate,
        graphql_name="createOrUpdateCustomSqlTemplate",
        args=sgqlc.types.ArgDict(
            (
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(QueryResultType, graphql_name="queryResultType", default=None),
                ),
                (
                    "sql_template",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="sqlTemplate", default=None
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update custom sql template

    Arguments:

    * `description` (`String`): Description of custom sql template
    * `dialect` (`String`): Dialect of custom sql template
    * `name` (`String`): Name of custom sql template
    * `query_result_type` (`QueryResultType`): CustomSQLTemplate's
      query result type can be set to SINGLE_NUMERIC, ROW_COUNT and
      LABELED_NUMERICS. The result is ROW_COUNT if unset
    * `sql_template` (`String!`): SQL template of custom sql template
    * `uuid` (`UUID`): UUID of custom sql template
    """

    delete_custom_sql_template = sgqlc.types.Field(
        DeleteCustomSQLTemplate,
        graphql_name="deleteCustomSqlTemplate",
        args=sgqlc.types.ArgDict(
            (("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),)
        ),
    )
    """Delete custom sql template

    Arguments:

    * `uuid` (`UUID`): uuid of custom sql template
    """

    stop_monitor = sgqlc.types.Field(
        "StopMonitor",
        graphql_name="stopMonitor",
        args=sgqlc.types.ArgDict(
            (("monitor_id", sgqlc.types.Arg(UUID, graphql_name="monitorId", default=None)),)
        ),
    )
    """Deletes a monitor

    Arguments:

    * `monitor_id` (`UUID`)None
    """

    delete_monitor = sgqlc.types.Field(
        DeleteMonitor,
        graphql_name="deleteMonitor",
        args=sgqlc.types.ArgDict(
            (("monitor_id", sgqlc.types.Arg(UUID, graphql_name="monitorId", default=None)),)
        ),
    )
    """Deletes a monitor

    Arguments:

    * `monitor_id` (`UUID`)None
    """

    create_or_update_monitor = sgqlc.types.Field(
        CreateOrUpdateMonitor,
        graphql_name="createOrUpdateMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agg_select_expression",
                    sgqlc.types.Arg(String, graphql_name="aggSelectExpression", default=None),
                ),
                (
                    "agg_time_interval",
                    sgqlc.types.Arg(
                        MonitorAggTimeInterval, graphql_name="aggTimeInterval", default=None
                    ),
                ),
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(CustomRuleComparisonInput),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "data_source",
                    sgqlc.types.Arg(DataSourceUnionInput, graphql_name="dataSource", default=None),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "disable_look_back_bootstrap",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="disableLookBackBootstrap", default=False
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failed_schedule_account_notification_id",
                    sgqlc.types.Arg(
                        UUID, graphql_name="failedScheduleAccountNotificationId", default=None
                    ),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fields", default=None
                    ),
                ),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                (
                    "high_segment_count",
                    sgqlc.types.Arg(Boolean, graphql_name="highSegmentCount", default=False),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                ("lookback_days", sgqlc.types.Arg(Int, graphql_name="lookbackDays", default=1)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "min_segment_size",
                    sgqlc.types.Arg(Int, graphql_name="minSegmentSize", default=None),
                ),
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        ScheduleConfigInput, graphql_name="scheduleConfig", default=None
                    ),
                ),
                (
                    "segmentation_type",
                    sgqlc.types.Arg(
                        SegmentationType, graphql_name="segmentationType", default=None
                    ),
                ),
                (
                    "segmented_expressions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="segmentedExpressions",
                        default=None,
                    ),
                ),
                (
                    "select_expressions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorSelectExpressionInput),
                        graphql_name="selectExpressions",
                        default=None,
                    ),
                ),
                (
                    "selected_metrics",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(FieldHealthMetrics),
                        graphql_name="selectedMetrics",
                        default=None,
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default=None)),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "time_axis_name",
                    sgqlc.types.Arg(String, graphql_name="timeAxisName", default=None),
                ),
                (
                    "time_axis_type",
                    sgqlc.types.Arg(String, graphql_name="timeAxisType", default=None),
                ),
                (
                    "unnest_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="unnestFields", default=None
                    ),
                ),
                (
                    "use_partition_clause",
                    sgqlc.types.Arg(Boolean, graphql_name="usePartitionClause", default=False),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `agg_select_expression` (`String`): (DEPRECATED) Option will be
      ignored
    * `agg_time_interval` (`MonitorAggTimeInterval`): For field health
      and dimension monitoring, the aggregation time interval to use.
      Either HOUR or DAY (defaults to HOUR)
    * `comparisons` (`[CustomRuleComparisonInput]`): Metric evaluator
      configuration.
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `data_quality_dimension` (`String`): Data quality dimension on
      the custom rule.
    * `data_source` (`DataSourceUnionInput`)None
    * `description` (`String`): Used as the name in the UI
    * `disable_look_back_bootstrap` (`Boolean`): The flag decides
      whether to disable look back bootstrap for new monitors. By
      default, it's False (default: `false`)
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failed_schedule_account_notification_id` (`UUID`): Account
      notification to be used when the monitor's scheduled executions
      fail.
    * `failure_audiences` (`[String!]`): The audiences to notify on
      failure
    * `fields` (`[String]`): Fields to monitor. DEPRECATED, use
      select_expressions instead.
    * `full_table_id` (`String`): Deprecated - use mcon. Ignored if
      mcon is present
    * `high_segment_count` (`Boolean`): Flag to apply additional
      limits which increase the supported segment count (default:
      `false`)
    * `labels` (`[String]`): The monitor labels
    * `lookback_days` (`Int`): Look-back period in days (to be applied
      by time axis) (default: `1`)
    * `mcon` (`String`): Mcon of table to create monitor for
    * `min_segment_size` (`Int`): Minimum number of rows for a segment
      to be retrieved. Segments with less rows than this will be
      discarded.
    * `monitor_type` (`String`): Type of monitor to create
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `resource_id` (`UUID`): Resource (e.g. warehouse) the table is
      contained in. Required when using a fullTableId
    * `schedule_config` (`ScheduleConfigInput`): Schedule of monitor
    * `segmentation_type` (`SegmentationType`): The type of
      segmentation specified in segmented_expressions. For instance
      field or custom_sql_expression.
    * `segmented_expressions` (`[String]`): Fields or expressions used
      to segment the monitored field (currently supports one such
      value)
    * `select_expressions` (`[MonitorSelectExpressionInput]`): Monitor
      select expressions
    * `selected_metrics` (`[FieldHealthMetrics]`): Only monitor the
      selected metrics. If empty, all metrics will be monitored. Only
      available for Field Health monitors.
    * `severity` (`String`): DEPRECATED. Use priority instead. The
      default severity for incidents involving this monitor
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `tags` (`[TagKeyValuePairInput]`): The monitor tags.
    * `time_axis_name` (`String`): Time axis name
    * `time_axis_type` (`String`): Time axis type
    * `unnest_fields` (`[String]`): Fields to unnest
    * `use_partition_clause` (`Boolean`): Whether to use automatic
      partition filter in query (default: `false`)
    * `uuid` (`UUID`): UUID of the monitor. If specified, it means the
      request is for update
    * `where_condition` (`String`): SQL WHERE condition to apply to
      query
    """

    pause_monitor = sgqlc.types.Field(
        "PauseMonitor",
        graphql_name="pauseMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "pause",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="pause", default=None
                    ),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Pause a monitor from collecting data.'

    Arguments:

    * `pause` (`Boolean!`): Pause state of the monitor.
    * `uuid` (`UUID!`): UUID of the monitor whose skip status is being
      changed.
    """

    resume_monitor_bootstrap = sgqlc.types.Field(
        "ResumeMonitorBootstrap",
        graphql_name="resumeMonitorBootstrap",
        args=sgqlc.types.ArgDict(
            (
                (
                    "ignore_limits",
                    sgqlc.types.Arg(Boolean, graphql_name="ignoreLimits", default=None),
                ),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Resume the monitor bootstrapping process

    Arguments:

    * `ignore_limits` (`Boolean`): Update bootstrap configuration to
      ignore table-size & segment cardinality limits
    * `uuid` (`UUID!`): UUID of the monitor to resume bootstrapping.
    """

    pause_monitor_bootstrap = sgqlc.types.Field(
        "PauseMonitorBootstrap",
        graphql_name="pauseMonitorBootstrap",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Pause the monitor bootstrapping process

    Arguments:

    * `uuid` (`UUID!`): UUID of the monitor to pause bootstrapping.
    """

    create_or_update_comparison_monitor = sgqlc.types.Field(
        CreateOrUpdateComparisonMonitor,
        graphql_name="createOrUpdateComparisonMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(ComparisonAlertConditionInput))
                        ),
                        graphql_name="alertConditions",
                        default=None,
                    ),
                ),
                (
                    "audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="audiences",
                        default=None,
                    ),
                ),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                (
                    "source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ExtendedDataSourceInput),
                        graphql_name="source",
                        default=None,
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                (
                    "target",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ExtendedDataSourceInput),
                        graphql_name="target",
                        default=None,
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """(experimental) Create or Update a Comparison Monitor

    Arguments:

    * `alert_conditions` (`[ComparisonAlertConditionInput!]!`): Alert
      conditions
    * `audiences` (`[String!]`): The monitor notification audiences
    * `data_quality_dimension` (`String`): Data quality dimension.
    * `description` (`String!`): Description of monitor
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The monitor notification
      audiences for failures
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of custom
      monitor
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. (default: `false`)
    * `source` (`ExtendedDataSourceInput!`): source for comparison
      monitor
    * `tags` (`[TagKeyValuePairInput!]`): The monitor tags.
    * `target` (`ExtendedDataSourceInput!`): target for comparison
      monitor
    * `uuid` (`UUID`): UUID of the monitor. If specified, it means the
      request is for update
    """

    create_or_update_metric_monitor = sgqlc.types.Field(
        CreateOrUpdateMetricMonitor,
        graphql_name="createOrUpdateMetricMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "aggregate",
                    sgqlc.types.Arg(AggregateInput, graphql_name="aggregate", default=None),
                ),
                (
                    "alert_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(MetricAlertConditionInput))
                        ),
                        graphql_name="alertConditions",
                        default=None,
                    ),
                ),
                (
                    "audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="audiences",
                        default=None,
                    ),
                ),
                (
                    "collection_lag_hours",
                    sgqlc.types.Arg(Int, graphql_name="collectionLagHours", default=0),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "disable_look_back_bootstrap",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="disableLookBackBootstrap", default=False
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "high_segment_count",
                    sgqlc.types.Arg(Boolean, graphql_name="highSegmentCount", default=False),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                (
                    "segment_count_hint",
                    sgqlc.types.Arg(Int, graphql_name="segmentCountHint", default=None),
                ),
                (
                    "segments",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(FilterValueUnionInput)),
                        graphql_name="segments",
                        default=None,
                    ),
                ),
                (
                    "sensitivity",
                    sgqlc.types.Arg(SensitivityLevels, graphql_name="sensitivity", default=None),
                ),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                (
                    "use_partition_clause",
                    sgqlc.types.Arg(Boolean, graphql_name="usePartitionClause", default=False),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """(experimental) Create or update a Metric monitor

    Arguments:

    * `aggregate` (`AggregateInput`): The time aggregation to use.
    * `alert_conditions` (`[MetricAlertConditionInput!]!`): Alert
      conditions.
    * `audiences` (`[String!]`): The monitor notification audiences
    * `collection_lag_hours` (`Int`): Collection lag in hours (for the
      provided timestamp) (default: `0`)
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `data_quality_dimension` (`String`): Data quality dimension.
    * `data_source` (`DataSourceUnionInput!`)None
    * `description` (`String!`): Used as the name in the UI
    * `disable_look_back_bootstrap` (`Boolean`): The flag decides
      whether to disable look back bootstrap for new monitors. By
      default, it's False (default: `false`)
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `dw_id` (`UUID!`): Warehouse the monitor will be run on.
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The monitor notification
      audiences for failures
    * `high_segment_count` (`Boolean`): Flag to apply additional
      limits which increase the supported segment count (default:
      `false`)
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of monitor
    * `segment_count_hint` (`Int`): Segment count when then monitor
      was created. Can be returned as the segment count for the
      monitor when no successful execution has yet occurred, and a
      fresh segment count is not available. This allows the UI to
      properly validate the monitor configuration and avoid creating
      monitors that will fail when they are created due too many
      metric combinations.
    * `segments` (`[FilterValueUnionInput!]`): Segments
    * `sensitivity` (`SensitivityLevels`): Sensitivity for automated
      thresholds.
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `tags` (`[TagKeyValuePairInput!]`): The monitor tags.
    * `timeout` (`Int`): Timeout for the SQL query
    * `use_partition_clause` (`Boolean`): Whether to use automatic
      partition filter in query (default: `false`)
    * `uuid` (`UUID`): UUID of the monitor. If specified, it means the
      request is for update
    * `where_condition` (`String`): SQL WHERE condition to apply to
      query
    """

    create_or_update_agent_monitor = sgqlc.types.Field(
        CreateOrUpdateAgentMonitor,
        graphql_name="createOrUpdateAgentMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_span_filters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilterInput))
                        ),
                        graphql_name="agentSpanFilters",
                        default=None,
                    ),
                ),
                (
                    "aggregate_by",
                    sgqlc.types.Arg(
                        MonitorAggTimeInterval, graphql_name="aggregateBy", default="HOUR"
                    ),
                ),
                (
                    "alert_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(MetricAlertConditionInput))
                        ),
                        graphql_name="alertConditions",
                        default=None,
                    ),
                ),
                (
                    "audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="audiences",
                        default=None,
                    ),
                ),
                (
                    "collection_lag_hours",
                    sgqlc.types.Arg(Int, graphql_name="collectionLagHours", default=0),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(FilterGroupInput, graphql_name="filters", default=None),
                ),
                (
                    "high_segment_count",
                    sgqlc.types.Arg(Boolean, graphql_name="highSegmentCount", default=False),
                ),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                (
                    "sampling_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MonitorSamplingConfigInput),
                        graphql_name="samplingConfig",
                        default=None,
                    ),
                ),
                (
                    "schedule_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ScheduleConfigInput),
                        graphql_name="scheduleConfig",
                        default=None,
                    ),
                ),
                (
                    "segment_count_hint",
                    sgqlc.types.Arg(Int, graphql_name="segmentCountHint", default=None),
                ),
                (
                    "segments",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(FilterValueUnionInput)),
                        graphql_name="segments",
                        default=None,
                    ),
                ),
                (
                    "sensitivity",
                    sgqlc.types.Arg(SensitivityLevels, graphql_name="sensitivity", default=None),
                ),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """(experimental) Create or update an Agent monitor

    Arguments:

    * `agent_span_filters` (`[AgentSpanFilterInput!]!`): Filter by
      agent span fields (agent, workflow, task, span_name)
    * `aggregate_by` (`MonitorAggTimeInterval`): Aggregation time
      interval. When not using a hourly interval, the timecomponent of
      the event timestamp should be ignored. (default: `"HOUR"`)
    * `alert_conditions` (`[MetricAlertConditionInput!]!`): Alert
      conditions.
    * `audiences` (`[String!]`): The monitor notification audiences
    * `collection_lag_hours` (`Int`): Collection lag in hours (for the
      provided timestamp) (default: `0`)
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `data_quality_dimension` (`String`): Data quality dimension.
    * `data_source` (`DataSourceUnionInput!`)None
    * `description` (`String!`): Used as the name in the UI
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `dw_id` (`UUID!`): Warehouse the monitor will be run on.
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The monitor notification
      audiences for failures
    * `filters` (`FilterGroupInput`): Structured SQL filtering
      conditions to apply to query
    * `high_segment_count` (`Boolean`): Flag to apply additional
      limits which increase the supported segment count (default:
      `false`)
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `sampling_config` (`MonitorSamplingConfigInput!`): Sampling
      configuration: either percentage or fixed count
    * `schedule_config` (`ScheduleConfigInput!`): Schedule of monitor
    * `segment_count_hint` (`Int`): Segment count when then monitor
      was created. Can be returned as the segment count for the
      monitor when no successful execution has yet occurred, and a
      fresh segment count is not available. This allows the UI to
      properly validate the monitor configuration and avoid creating
      monitors that will fail when they are created due too many
      metric combinations.
    * `segments` (`[FilterValueUnionInput!]`): Segments
    * `sensitivity` (`SensitivityLevels`): Sensitivity for automated
      thresholds.
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `tags` (`[TagKeyValuePairInput!]`): The monitor tags.
    * `uuid` (`UUID`): UUID of the monitor. If specified, it means the
      request is for update
    """

    create_or_update_json_schema_monitor = sgqlc.types.Field(
        CreateOrUpdateJsonSchemaMonitor,
        graphql_name="createOrUpdateJsonSchemaMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="audiences",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "data_quality_dimension",
                    sgqlc.types.Arg(String, graphql_name="dataQualityDimension", default=None),
                ),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "domain_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainUuids",
                        default=None,
                    ),
                ),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "fail_on_reset",
                    sgqlc.types.Arg(Boolean, graphql_name="failOnReset", default=False),
                ),
                (
                    "failure_audiences",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="failureAudiences",
                        default=None,
                    ),
                ),
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                ("is_draft", sgqlc.types.Arg(Boolean, graphql_name="isDraft", default=False)),
                ("notes", sgqlc.types.Arg(String, graphql_name="notes", default="")),
                (
                    "notify_rule_run_failure",
                    sgqlc.types.Arg(Boolean, graphql_name="notifyRuleRunFailure", default=None),
                ),
                ("priority", sgqlc.types.Arg(String, graphql_name="priority", default=None)),
                ("skip_reset", sgqlc.types.Arg(Boolean, graphql_name="skipReset", default=False)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                (
                    "time_axis",
                    sgqlc.types.Arg(FilterValueUnionInput, graphql_name="timeAxis", default=None),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """(experimental) Create or update a JSON schema monitor

    Arguments:

    * `audiences` (`[String!]`): The monitor notification audiences
    * `connection_id` (`UUID`): Specify a connection (e.g. query-
      engine) to use
    * `data_quality_dimension` (`String`): Data quality dimension.
    * `data_source` (`DataSourceUnionInput!`)None
    * `description` (`String!`): Used as the name in the UI
    * `domain_uuids` (`[UUID!]`): Please provide one and only one
      valid domain uuid.
    * `dry_run` (`Boolean`): Dry run the monitor creation or update
      and return the MaC YAML and queries. (default: `false`)
    * `dw_id` (`UUID!`): Warehouse the monitor will be run on.
    * `fail_on_reset` (`Boolean`): Return an error if the update is a
      significant change that would require a monitor reset. (default:
      `false`)
    * `failure_audiences` (`[String!]`): The monitor notification
      audiences for failures
    * `field` (`String!`): Field to monitor
    * `is_draft` (`Boolean`): Make target a draft monitor. (default:
      `false`)
    * `notes` (`String`): Additional context for the monitor (default:
      `""`)
    * `notify_rule_run_failure` (`Boolean`): DEPRECATED: Completely
      ignored. This field has no effect on anything. Use
      `failure_audiences` to determine who is notified when run
      failures occur.
    * `priority` (`String`): The default priority for alerts involving
      this monitor
    * `skip_reset` (`Boolean`): Do not reset monitor if the update is
      a significant change that would normally cause the monitor to be
      reset. Learned model might not match the new monitor
      configuration and false positives might be detected for up to 35
      days (default: `false`)
    * `tags` (`[TagKeyValuePairInput!]`): The monitor tags.
    * `time_axis` (`FilterValueUnionInput`): Time axis to filter
      recent data by
    * `uuid` (`UUID`): UUID of the monitor. If specified, it means the
      request is for update
    * `where_condition` (`String`): SQL WHERE condition to apply to
      query
    """

    validate_cron = sgqlc.types.Field(
        "ValidateCron",
        graphql_name="validateCron",
        args=sgqlc.types.ArgDict(
            (
                (
                    "allow_multiple",
                    sgqlc.types.Arg(Boolean, graphql_name="allowMultiple", default=None),
                ),
                (
                    "cron",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="cron", default=None
                    ),
                ),
            )
        ),
    )
    """Validate a CRON expression

    Arguments:

    * `allow_multiple` (`Boolean`): Allow multiple CRON expressions
    * `cron` (`String!`): CRON expression
    """

    set_event_detector_feedback = sgqlc.types.Field(
        "SetEventDetectorFeedback",
        graphql_name="setEventDetectorFeedback",
        args=sgqlc.types.ArgDict(
            (
                (
                    "event_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="eventId", default=None
                    ),
                ),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "is_false_positive",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="isFalsePositive", default=None
                    ),
                ),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """(experimental) Set event feedback for detector

    Arguments:

    * `event_id` (`UUID!`)None
    * `field` (`String`)None
    * `is_false_positive` (`Boolean!`)None
    * `metric` (`String`)None
    * `where_condition` (`String`)None
    """

    set_event_detector_feedback_by_alert = sgqlc.types.Field(
        "SetEventDetectorFeedbackByAlert",
        graphql_name="setEventDetectorFeedbackByAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "is_false_positive",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="isFalsePositive", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set feedback for detector on all events in the
    alert

    Arguments:

    * `alert_id` (`UUID!`)None
    * `is_false_positive` (`Boolean!`)None
    """

    set_incident_feedback = sgqlc.types.Field(
        "SetIncidentFeedbackPayload",
        graphql_name="setIncidentFeedback",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SetIncidentFeedbackInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Provide feedback for an incident

    Arguments:

    * `input` (`SetIncidentFeedbackInput!`)None
    """

    set_incident_feedback_v2 = sgqlc.types.Field(
        "SetIncidentFeedbackV2Payload",
        graphql_name="setIncidentFeedbackV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SetIncidentFeedbackV2Input),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Provide feedback for an incident

    Arguments:

    * `input` (`SetIncidentFeedbackV2Input!`)None
    """

    set_incident_severity = sgqlc.types.Field(
        "SetIncidentSeverity",
        graphql_name="setIncidentSeverity",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Set severity for an incident

    Arguments:

    * `incident_id` (`UUID!`): The incident's UUID
    * `severity` (`String`): Incident severity to set. Options are:
      SEV-1, SEV-2, SEV-3, SEV-4. If this field is omitted or its
      value is set to null then severity value is cleared
    """

    set_alert_severity = sgqlc.types.Field(
        "SetAlertSeverity",
        graphql_name="setAlertSeverity",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("severity", sgqlc.types.Arg(SeverityInput, graphql_name="severity", default=None)),
            )
        ),
    )
    """(experimental) Set severity for an alert

    Arguments:

    * `alert_id` (`UUID!`): The alert/incident's UUID
    * `severity` (`SeverityInput`): Severity to set. If omitted,
      severity is cleared (i.e. incident is demoted to alert)
    """

    create_or_update_incident_comment = sgqlc.types.Field(
        CreateOrUpdateIncidentComment,
        graphql_name="createOrUpdateIncidentComment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comment",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="comment", default=None
                    ),
                ),
                ("comment_id", sgqlc.types.Arg(UUID, graphql_name="commentId", default=None)),
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Creates or updates a comment on an
    incident

    Arguments:

    * `comment` (`String!`): Content of the comment
    * `comment_id` (`UUID`): UUID of the comment. If set, this call is
      for updating the comment
    * `incident_id` (`UUID!`): The incident's UUID
    """

    create_or_update_alert_comment = sgqlc.types.Field(
        CreateOrUpdateAlertComment,
        graphql_name="createOrUpdateAlertComment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "comment",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="comment", default=None
                    ),
                ),
                ("comment_id", sgqlc.types.Arg(UUID, graphql_name="commentId", default=None)),
            )
        ),
    )
    """(experimental) Creates or updates a comment on an alert

    Arguments:

    * `alert_id` (`UUID!`): The alert's UUID
    * `comment` (`String!`): Content of the comment
    * `comment_id` (`UUID`): UUID of the comment. If set, this call is
      for updating the comment
    """

    set_alert_owner = sgqlc.types.Field(
        "SetAlertOwner",
        graphql_name="setAlertOwner",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("owner", sgqlc.types.Arg(String, graphql_name="owner", default=None)),
            )
        ),
    )
    """(experimental) Set the owner for an alert

    Arguments:

    * `alert_id` (`UUID!`): The alert's UUID
    * `owner` (`String`): Alert owner's email to set
    """

    set_incident_owner = sgqlc.types.Field(
        "SetIncidentOwner",
        graphql_name="setIncidentOwner",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
                ("owner", sgqlc.types.Arg(String, graphql_name="owner", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Set owner for an incident

    Arguments:

    * `incident_id` (`UUID!`): The incident's UUID
    * `owner` (`String`): Incident owner to set
    """

    delete_incident_comment = sgqlc.types.Field(
        DeleteIncidentComment,
        graphql_name="deleteIncidentComment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comment_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="commentId", default=None
                    ),
                ),
            )
        ),
    )
    """Deletes an incident's comment

    Arguments:

    * `comment_id` (`UUID!`): UUID of the comment for update
    """

    delete_alert_comment = sgqlc.types.Field(
        DeleteAlertComment,
        graphql_name="deleteAlertComment",
        args=sgqlc.types.ArgDict(
            (
                (
                    "comment_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="commentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Deletes an alert's comment

    Arguments:

    * `comment_id` (`UUID!`): UUID of the comment for update
    """

    split_incident = sgqlc.types.Field(
        "SplitIncident",
        graphql_name="splitIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "event_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="eventUuids",
                        default=None,
                    ),
                ),
                (
                    "incident_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentUuid", default=None
                    ),
                ),
                (
                    "send_notification",
                    sgqlc.types.Arg(Boolean, graphql_name="sendNotification", default=False),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Splits event/s from incident into a new
    incident

    Arguments:

    * `event_uuids` (`[UUID]!`): unique identifier of event/s to split
      to new incident
    * `incident_uuid` (`UUID!`): Incident unique identifier
    * `send_notification` (`Boolean`): Whether to send a notification
      for the new incident (default: `false`)
    """

    split_alert = sgqlc.types.Field(
        "SplitAlert",
        graphql_name="splitAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertUuid", default=None
                    ),
                ),
                (
                    "event_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="eventUuids",
                        default=None,
                    ),
                ),
                (
                    "send_notification",
                    sgqlc.types.Arg(Boolean, graphql_name="sendNotification", default=False),
                ),
            )
        ),
    )
    """(experimental) Splits event/s from alert into a new alert

    Arguments:

    * `alert_uuid` (`UUID!`): Alert unique identifier
    * `event_uuids` (`[UUID]!`): unique identifier of event/s to split
      to new alert
    * `send_notification` (`Boolean`): Whether to send a notification
      for the new alert (default: `false`)
    """

    bulk_update_incidents = sgqlc.types.Field(
        BulkUpdateIncidents,
        graphql_name="bulkUpdateIncidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "new_values",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(BulkUpdateIncidentsValues),
                        graphql_name="newValues",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Bulk update incidents

    Arguments:

    * `new_values` (`BulkUpdateIncidentsValues!`): New values to apply
      to incidents supplied by uuids
    * `uuids` (`[UUID]!`): UUIDs of incidents to update
    """

    bulk_update_alerts = sgqlc.types.Field(
        BulkUpdateAlerts,
        graphql_name="bulkUpdateAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "new_values",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(BulkUpdateAlertsValues),
                        graphql_name="newValues",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="uuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Bulk update alerts

    Arguments:

    * `new_values` (`BulkUpdateAlertsValues!`): New values to apply to
      alerts supplied by uuids
    * `uuids` (`[UUID]!`): UUIDs of alerts to update
    """

    update_alert = sgqlc.types.Field(
        "UpdateAlert",
        graphql_name="updateAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "declared_incident_severity",
                    sgqlc.types.Arg(
                        SeverityInput, graphql_name="declaredIncidentSeverity", default=None
                    ),
                ),
                ("feedback", sgqlc.types.Arg(String, graphql_name="feedback", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("severity", sgqlc.types.Arg(String, graphql_name="severity", default=None)),
                ("status", sgqlc.types.Arg(AlertStatusInput, graphql_name="status", default=None)),
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Only supplied fields will be updated for the alert

    Arguments:

    * `declared_incident_severity` (`SeverityInput`): By assigning a
      severity to the alert, the alert will be declared an incident
    * `feedback` (`String`): DEPRECATED: Use status instead. Options:
      helpful, not helpful, fixed, expected, investigating,
      false_positive, no_action_needed, work_in_progress,
      anomaly_normalized. Clear the value by setting it to empty
      string.
    * `name` (`String`): Custom name for the alert. Clear the value by
      setting it to empty string.)
    * `severity` (`String`): DEPRECATED: Use declaredIncidentSeverity
      instead. Options: {',
      '.join(DeclaredIncidentModel.Severity.values)} or (SEV_1, SEV_2,
      SEV_3, SEV_4). Clear the value by setting it to empty string.
    * `status` (`AlertStatusInput`): Status to assign to the alert.
    * `uuid` (`UUID!`): UUID of the alert to update
    """

    send_alert_invite = sgqlc.types.Field(
        "SendAlertInvite",
        graphql_name="sendAlertInvite",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "email",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="email", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Send an invitation to a non-user for an alert

    Arguments:

    * `alert_id` (`UUID!`): The alert's UUID
    * `email` (`String!`): Invitee's email
    """

    create_or_update_domain = sgqlc.types.Field(
        CreateOrUpdateDomain,
        graphql_name="createOrUpdateDomain",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assignments",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="assignments", default=None
                    ),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "excluded_assignments",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="excludedAssignments",
                        default=None,
                    ),
                ),
                (
                    "excluded_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput),
                        graphql_name="excludedTags",
                        default=None,
                    ),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a domain

    Arguments:

    * `assignments` (`[String]`): Objects assigned to domain (as
      MCONs)
    * `description` (`String`): Description of the domain
    * `excluded_assignments` (`[String]`): Objects excluded from
      domain (as MCONs)
    * `excluded_tags` (`[TagKeyValuePairInput]`): Filter out by tag
      key/value pairs for tables.
    * `name` (`String!`): Domain name
    * `tags` (`[TagKeyValuePairInput]`): Filter by tag key/value pairs
      for tables.
    * `uuid` (`UUID`): UUID of domain to update
    """

    delete_domain = sgqlc.types.Field(
        DeleteDomain,
        graphql_name="deleteDomain",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Delete a domain

    Arguments:

    * `uuid` (`UUID!`): UUID of domain to delete
    """

    create_or_update_authorization_group = sgqlc.types.Field(
        CreateOrUpdateAuthorizationGroup,
        graphql_name="createOrUpdateAuthorizationGroup",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_restriction_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID),
                        graphql_name="connectionRestrictionIds",
                        default=None,
                    ),
                ),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "domain_restriction_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainRestrictionIds", default=None
                    ),
                ),
                ("label", sgqlc.types.Arg(String, graphql_name="label", default=None)),
                (
                    "member_user_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="memberUserIds", default=None
                    ),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                (
                    "roles",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="roles",
                        default=None,
                    ),
                ),
                ("sso_group", sgqlc.types.Arg(String, graphql_name="ssoGroup", default=None)),
                ("version", sgqlc.types.Arg(String, graphql_name="version", default=None)),
            )
        ),
    )
    """Create or update an authorization group.

    Arguments:

    * `connection_restriction_ids` (`[UUID]`): Optional list of
      connection UUIDs to restrict visibility to. If not provided,
      will clear/apply no restrictions.
    * `description` (`String`): Description/help text to help users
      understand the purpose of the group. If not provided on updates,
      will keep current value.
    * `domain_restriction_ids` (`[UUID]`): Optional list of domain IDs
      to restrict access to. If not provided, will clear/apply no
      restrictions.
    * `label` (`String`): UI/user-friendly display name, ex: Data
      Consumers. If not provided on updates, will keep current value.
    * `member_user_ids` (`[String]`): User IDs of group members. If
      not provided, no changes to membership will be performed.
    * `name` (`String!`): Unique to the account, human-readable name
      (for use in code/policy reference).
    * `roles` (`[String]!`): Role names assigned to the group.
    * `sso_group` (`String`): SSO group name to map this authorization
      group to
    * `version` (`String`): Version of the permissions definitions the
      group is designed for ex: 2022-03-17. Defaults to system
      current. If not provided on updates, will keep current value.
    """

    delete_authorization_group = sgqlc.types.Field(
        DeleteAuthorizationGroup,
        graphql_name="deleteAuthorizationGroup",
        args=sgqlc.types.ArgDict(
            (("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),)
        ),
    )
    """Delete an authorization group

    Arguments:

    * `name` (`String`): Unique to the account, human-readable name
      name (for use in code/policy reference).
    """

    update_user_authorization_group_membership = sgqlc.types.Field(
        "UpdateUserAuthorizationGroupMembership",
        graphql_name="updateUserAuthorizationGroupMembership",
        args=sgqlc.types.ArgDict(
            (
                (
                    "group_names",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="groupNames",
                        default=None,
                    ),
                ),
                (
                    "member_user_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="memberUserId", default=None
                    ),
                ),
            )
        ),
    )
    """Update a user's authorization group membership. Authenticated user
    must have permission to manage users.

    Arguments:

    * `group_names` (`[String]!`): List of authorization group names
      the user should be a member of.
    * `member_user_id` (`String!`): User ID for the user whose
      membership is being updated.
    """

    create_or_update_auth_provisioning = sgqlc.types.Field(
        CreateOrUpdateAuthProvisioning,
        graphql_name="createOrUpdateAuthProvisioning",
        args=sgqlc.types.ArgDict(
            (
                (
                    "default_roles",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="defaultRoles", default=None
                    ),
                ),
                (
                    "domain_restriction_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainRestrictionIds", default=None
                    ),
                ),
                ("enabled", sgqlc.types.Arg(Boolean, graphql_name="enabled", default=None)),
                (
                    "provider_name",
                    sgqlc.types.Arg(String, graphql_name="providerName", default=None),
                ),
                (
                    "schema",
                    sgqlc.types.Arg(ProvisioningSchema, graphql_name="schema", default=None),
                ),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """(experimental) Create or Update the account Auth Provisioning
    configuration.

    Arguments:

    * `default_roles` (`[String]`): The default role names to be
      assigned to authorization groups created by this provisioning
      system.
    * `domain_restriction_ids` (`[UUID]`): Optional list of domain IDs
      to restrict access to. If not provided, will clear/apply no
      restrictions.
    * `enabled` (`Boolean`): Is this auth configuration enabled.
    * `provider_name` (`String`): Friendly name to help identify the
      provider system being configured.
    * `schema` (`ProvisioningSchema`): The schema type for this auth
      provisioning.
    * `uuid` (`UUID`): For updating an auth provisioning config.
    """

    request_access = sgqlc.types.Field(
        AccessRequestOutput,
        graphql_name="requestAccess",
        args=sgqlc.types.ArgDict(
            (
                ("reason", sgqlc.types.Arg(String, graphql_name="reason", default=None)),
                ("target_id", sgqlc.types.Arg(String, graphql_name="targetId", default=None)),
                (
                    "target_permission",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Permission),
                        graphql_name="targetPermission",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Request permissions that the user is missing

    Arguments:

    * `reason` (`String`): Reason for requesting access
    * `target_id` (`String`): Object ID access was requested for
    * `target_permission` (`Permission!`): Permission requested
    """

    create_or_update_resource = sgqlc.types.Field(
        CreateOrUpdateResource,
        graphql_name="createOrUpdateResource",
        args=sgqlc.types.ArgDict(
            (
                ("is_default", sgqlc.types.Arg(Boolean, graphql_name="isDefault", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Create or update a resource

    Arguments:

    * `is_default` (`Boolean`): If the account's default resource
    * `name` (`String`): The resource name
    * `type` (`String`): The resource type
    * `uuid` (`UUID`): The resource id
    """

    match_and_create_bi_warehouse_sources = sgqlc.types.Field(
        MatchAndCreateBiWarehouseSources,
        graphql_name="matchAndCreateBiWarehouseSources",
        args=sgqlc.types.ArgDict(
            (
                (
                    "bi_container_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="biContainerId", default=None
                    ),
                ),
                (
                    "bi_warehouse_sources",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(BiWarehouseSourcesInput),
                        graphql_name="biWarehouseSources",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Create or update a BI warehouse source. If BI warehouse source
    details are provided in the bi_warehouse_sources parameter then
    those are saved. Else, details are pulled from the BI APIs,
    matched with warehouses in Monte Carlo and details saved only if
    there is a full match.

    Arguments:

    * `bi_container_id` (`UUID!`): Monte Carlo UUID of the BI
      container
    * `bi_warehouse_sources` (`[BiWarehouseSourcesInput]`): BI
      warehouse source details that should be saved in Monte Carlo.
    """

    toggle_disable_sampling = sgqlc.types.Field(
        "ToggleDisableSampling",
        graphql_name="toggleDisableSampling",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disable", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """Enable/disable the sampling data feature

    Arguments:

    * `disable` (`Boolean!`): If true, disable the sampling data
      feature
    * `dw_id` (`UUID!`): The warehouse's UUID
    """

    toggle_restrict_sampling = sgqlc.types.Field(
        "ToggleRestrictSampling",
        graphql_name="toggleRestrictSampling",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
            )
        ),
    )
    """Enable/disable to restrict certain roles to access sampling data

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID
    * `enable` (`Boolean!`): If true, restrict certain roles to access
      sampling data
    """

    toggle_disable_value_ingestion = sgqlc.types.Field(
        "ToggleDisableValueIngestion",
        graphql_name="toggleDisableValueIngestion",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disable", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. End of life: September 03, 2024.
    DEPRECATED

    Arguments:

    * `disable` (`Boolean!`): If true, disable the value ingestion
      feature
    * `dw_id` (`UUID!`): The warehouse's UUID
    """

    toggle_disable_value_sampling_when_testing = sgqlc.types.Field(
        "ToggleDisableValueSamplingWhenTesting",
        graphql_name="toggleDisableValueSamplingWhenTesting",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disable", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """Enable/disable the sampling data feature when testing value-based
    sql rules

    Arguments:

    * `disable` (`Boolean!`): If true, disable the feature
    * `dw_id` (`UUID!`): The warehouse's UUID
    """

    toggle_enable_full_distribution_metrics = sgqlc.types.Field(
        "ToggleFullDistributionMetrics",
        graphql_name="toggleEnableFullDistributionMetrics",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. End of life: August 12, 2024.
    DEPRECATED

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID
    * `enable` (`Boolean!`): If true, enable full distribution metrics
    """

    toggle_warehouse_tags_collection_setting = sgqlc.types.Field(
        "ToggleWarehouseTagsCollectionSetting",
        graphql_name="toggleWarehouseTagsCollectionSetting",
        args=sgqlc.types.ArgDict(
            (
                (
                    "is_enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="isEnabled", default=None
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable/disable tags collection for a warehouse.

    Arguments:

    * `is_enabled` (`Boolean!`): If true, enable tags collection
    * `warehouse_uuid` (`UUID!`): The warehouse's UUID
    """

    save_table_importance_stats = sgqlc.types.Field(
        "SaveTableImportanceStats",
        graphql_name="saveTableImportanceStats",
        args=sgqlc.types.ArgDict(
            (
                (
                    "importance_score",
                    sgqlc.types.Arg(Float, graphql_name="importanceScore", default=None),
                ),
                (
                    "is_important",
                    sgqlc.types.Arg(Boolean, graphql_name="isImportant", default=None),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Save custom table stats for a table

    Arguments:

    * `importance_score` (`Float`): User-provided importance score.
    * `is_important` (`Boolean`): Whether the table is a key asset or
      not.
    * `mcon` (`String!`): The MCON of the table whose stats are being
      updated.
    """

    set_default_incident_group_interval = sgqlc.types.Field(
        "SetDefaultIncidentGroupInterval",
        graphql_name="setDefaultIncidentGroupInterval",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "interval",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="interval", default=None
                    ),
                ),
            )
        ),
    )
    """Set default incident grouping interval (in hours) for a warehouse.

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID.
    * `interval` (`Int!`): Interval in hours.
    """

    set_default_alert_group_interval = sgqlc.types.Field(
        "SetDefaultAlertGroupInterval",
        graphql_name="setDefaultAlertGroupInterval",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "interval",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="interval", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set default alert grouping interval (in hours) for
    a warehouse

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID.
    * `interval` (`Int!`): Interval in hours.
    """

    set_default_lineage_incident_grouping = sgqlc.types.Field(
        "SetDefaultLineageIncidentGrouping",
        graphql_name="setDefaultLineageIncidentGrouping",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enabled", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Set default lineage grouping for
    incident for a warehouse.

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID.
    * `enabled` (`Boolean!`): Whether to enable or disable lineage
      grouping
    """

    set_default_lineage_alert_grouping = sgqlc.types.Field(
        "SetDefaultLineageAlertGrouping",
        graphql_name="setDefaultLineageAlertGrouping",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enabled", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set default lineage grouping for alert for a
    warehouse.

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID.
    * `enabled` (`Boolean!`): Whether to enable or disable lineage
      grouping
    """

    toggle_incident_grouping = sgqlc.types.Field(
        "ToggleIncidentGrouping",
        graphql_name="toggleIncidentGrouping",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disabled", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Enable/disable incident grouping for a
    warehouse.

    Arguments:

    * `disabled` (`Boolean!`): Whether to enable or disable grouping
    * `dw_id` (`UUID!`): The warehouse's UUID.
    """

    toggle_alert_grouping = sgqlc.types.Field(
        "ToggleAlertGrouping",
        graphql_name="toggleAlertGrouping",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disabled", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """(experimental) Enable/disable alert grouping for a warehouse.

    Arguments:

    * `disabled` (`Boolean!`): Whether to enable or disable grouping
    * `dw_id` (`UUID!`): The warehouse's UUID.
    """

    toggle_schema_change_incident_grouping = sgqlc.types.Field(
        "ToggleSchemaChangeIncidentGrouping",
        graphql_name="toggleSchemaChangeIncidentGrouping",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disabled", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Enable/disable schema change incident
    grouping for a warehouse.

    Arguments:

    * `disabled` (`Boolean!`): Whether to enable or disable grouping
    * `dw_id` (`UUID!`): The warehouse's UUID.
    """

    toggle_schema_change_alert_grouping = sgqlc.types.Field(
        "ToggleSchemaChangeAlertGrouping",
        graphql_name="toggleSchemaChangeAlertGrouping",
        args=sgqlc.types.ArgDict(
            (
                (
                    "disabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="disabled", default=None
                    ),
                ),
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """(experimental) Enable/disable schema change alert grouping for a
    warehouse.

    Arguments:

    * `disabled` (`Boolean!`): Whether to enable or disable grouping
    * `dw_id` (`UUID!`): The warehouse's UUID.
    """

    toggle_wildcard_aggregation = sgqlc.types.Field(
        "ToggleWildcardAggregation",
        graphql_name="toggleWildcardAggregation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
            )
        ),
    )
    """Enables/disable aggregation of wildcard tables (defaults to yearly
    and monthly templates)

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID
    * `enable` (`Boolean!`): If true, enable full wildcard aggregation
    """

    toggle_create_alerts_in_datasource = sgqlc.types.Field(
        "ToggleCreateAlertsInDatasource",
        graphql_name="toggleCreateAlertsInDatasource",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable/disable the creation of alerts in the
    warehouse (when supported)

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID
    * `enable` (`Boolean!`): If true, enable the creation of alerts in
      data source
    """

    set_wildcard_templates = sgqlc.types.Field(
        "SetWildcardTemplates",
        graphql_name="setWildcardTemplates",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "templates",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(WildcardTemplateInput)),
                        graphql_name="templates",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Sets the templates to use for wildcard aggregation (overrides
    existing templates)

    Arguments:

    * `dw_id` (`UUID!`): The warehouse's UUID
    * `templates` (`[WildcardTemplateInput]!`): List of templates to
      use to aggregate wildcard tables
    """

    set_custom_sql_sampling_size = sgqlc.types.Field(
        "SetCustomSqlSamplingSize",
        graphql_name="setCustomSqlSamplingSize",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_sql_sampling_size",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int),
                        graphql_name="customSqlSamplingSize",
                        default=None,
                    ),
                ),
                (
                    "warehouse_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set the custom sql data sampling size in the
    warehouse.

    Arguments:

    * `custom_sql_sampling_size` (`Int!`): Sampling size for custom
      sql monitors. The size can't be over 5000.
    * `warehouse_id` (`UUID!`): The warehouse's UUID
    """

    create_shared_query = sgqlc.types.Field(
        CreateSharedQuery,
        graphql_name="createSharedQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "content",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="content", default=None
                    ),
                ),
                (
                    "expiration_in_days",
                    sgqlc.types.Arg(Int, graphql_name="expirationInDays", default=None),
                ),
                ("type", sgqlc.types.Arg(SharedQueryTypeEnum, graphql_name="type", default=None)),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
            )
        ),
    )
    """Create a new shared API Explorer GraphQL query or mutation

    Arguments:

    * `content` (`String!`): API Explorer GraphQL operation content.
      Maximum size is 1MB.
    * `expiration_in_days` (`Int`): Number of days to expire the
      temporary link, max and default expiration is 7 days
    * `type` (`SharedQueryTypeEnum`): Type of shared GraphQL
      operation: temporary (default) or permanent (internal only)
    * `variables` (`JSONString`): API Explorer GraphQL variables.
      Maximum size is 1MB.
    """

    create_or_update_user_settings = sgqlc.types.Field(
        CreateOrUpdateUserSettings,
        graphql_name="createOrUpdateUserSettings",
        args=sgqlc.types.ArgDict(
            (
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                ("value", sgqlc.types.Arg(JSONString, graphql_name="value", default=None)),
            )
        ),
    )
    """(experimental) Create or update a user-specific setting

    Arguments:

    * `description` (`String`): Description for this user's settings
    * `key` (`String!`): User setting key
    * `value` (`JSONString`): User settings
    """

    create_or_update_user_settings_batch = sgqlc.types.Field(
        CreateOrUpdateUserSettingsBatch,
        graphql_name="createOrUpdateUserSettingsBatch",
        args=sgqlc.types.ArgDict(
            (
                (
                    "settings",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(UserSettingInput))
                        ),
                        graphql_name="settings",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update a list of user-specific settings

    Arguments:

    * `settings` (`[UserSettingInput!]!`): List of user settings to
      create or update
    """

    update_user_state = sgqlc.types.Field(
        "UpdateUserStatePayload",
        graphql_name="updateUserState",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UpdateUserStateInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `input` (`UpdateUserStateInput!`)None
    """

    update_user_persona = sgqlc.types.Field(
        "UpdateUserPersona",
        graphql_name="updateUserPersona",
        args=sgqlc.types.ArgDict(
            (("persona", sgqlc.types.Arg(UserPersona, graphql_name="persona", default=None)),)
        ),
    )
    """Update a persona that can help personalize the home page
    experience and the onboarding flow.

    Arguments:

    * `persona` (`UserPersona`)None
    """

    update_account_display_assets_search_tags = sgqlc.types.Field(
        "UpdateAccountDisplayCatalogSearchTags",
        graphql_name="updateAccountDisplayAssetsSearchTags",
        args=sgqlc.types.ArgDict(
            (
                (
                    "display",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="display", default=None
                    ),
                ),
            )
        ),
    )
    """Updates account-level setting for displaying search tags on assets
    ui

    Arguments:

    * `display` (`Boolean!`)None
    """

    set_account_name = sgqlc.types.Field(
        "SetAccountName",
        graphql_name="setAccountName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "account_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="accountName", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `account_name` (`String!`)None
    """

    set_account_billing_plan = sgqlc.types.Field(
        "SetAccountBillingPlan",
        graphql_name="setAccountBillingPlan",
        args=sgqlc.types.ArgDict(
            (
                (
                    "async_invoke",
                    sgqlc.types.Arg(Boolean, graphql_name="asyncInvoke", default=True),
                ),
                (
                    "billing_plan_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(BillingPlanType),
                        graphql_name="billingPlanType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Sets the billing plan for an account and create the customer in
    the billing vendor

    Arguments:

    * `async_invoke` (`Boolean`): Whether to set account's contract
      change asynchronously (default: `true`)
    * `billing_plan_type` (`BillingPlanType!`): The Rate Card type
      that will be used to create an initial customer contract
    """

    set_account_max_time_series = sgqlc.types.Field(
        "SetMaxTimeSeries",
        graphql_name="setAccountMaxTimeSeries",
        args=sgqlc.types.ArgDict(
            (
                (
                    "max_time_series",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="maxTimeSeries", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set the maximum number of time series for the
    account.

    Arguments:

    * `max_time_series` (`Int!`)None
    """

    set_warehouse_name = sgqlc.types.Field(
        "SetWarehouseName",
        graphql_name="setWarehouseName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """Set friendly name for a warehouse.

    Arguments:

    * `dw_id` (`UUID!`): UUID of the warehouse to update.
    * `name` (`String!`): Desired name.
    """

    set_etl_container_name = sgqlc.types.Field(
        "SetEtlContainerName",
        graphql_name="setEtlContainerName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "etl_container_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="etlContainerId", default=None
                    ),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """Set friendly name for a ETL container.

    Arguments:

    * `etl_container_id` (`UUID!`): UUID of the ETL container to
      update.
    * `name` (`String!`): Desired name.
    """

    set_connection_name = sgqlc.types.Field(
        "SetConnectionName",
        graphql_name="setConnectionName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set the name of a connection model.

    Arguments:

    * `connection_id` (`UUID!`): UUID of the connection to update.
    * `name` (`String!`): Desired name.
    """

    set_integration_name = sgqlc.types.Field(
        "SetIntegrationName",
        graphql_name="setIntegrationName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "integration_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="integrationType", default=None
                    ),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Set the name of an integration.

    Arguments:

    * `integration_id` (`UUID!`): UUID of the integration to update.
    * `integration_type` (`String!`): Integration type for direct
      routing.
    * `name` (`String!`): Desired name.
    """

    create_or_update_saml_identity_provider = sgqlc.types.Field(
        CreateOrUpdateSamlIdentityProvider,
        graphql_name="createOrUpdateSamlIdentityProvider",
        args=sgqlc.types.ArgDict(
            (
                (
                    "account_identifier",
                    sgqlc.types.Arg(String, graphql_name="accountIdentifier", default=None),
                ),
                (
                    "default_authorization_groups",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="defaultAuthorizationGroups",
                        default=None,
                    ),
                ),
                (
                    "domains",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="domains",
                        default=None,
                    ),
                ),
                ("metadata", sgqlc.types.Arg(String, graphql_name="metadata", default=None)),
                ("metadata_url", sgqlc.types.Arg(String, graphql_name="metadataUrl", default=None)),
            )
        ),
    )
    """Arguments:

    * `account_identifier` (`String`): An account identifier
      authorized by the IdP
    * `default_authorization_groups` (`[String]`): One or more
      authorization group names to assign to new SSO users who do not
      have an invite. If none/not set, it means new users must wait to
      be assigned group to gain any access.
    * `domains` (`[String]!`): A list of domains authorized by the IdP
    * `metadata` (`String`): The metadata in XML format, encoded as
      base64
    * `metadata_url` (`String`): The URL of the metadata file
    """

    delete_saml_identity_provider = sgqlc.types.Field(
        DeleteSamlIdentityProvider, graphql_name="deleteSamlIdentityProvider"
    )

    invite_users = sgqlc.types.Field(
        InviteUsersPayload,
        graphql_name="inviteUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(InviteUsersInput), graphql_name="input", default=None
                    ),
                ),
            )
        ),
    )
    """DEPRECATED: use inviteUsersV2

    Arguments:

    * `input` (`InviteUsersInput!`)None
    """

    invite_users_v2 = sgqlc.types.Field(
        InviteUsersV2,
        graphql_name="inviteUsersV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "auth_groups",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="authGroups",
                        default=None,
                    ),
                ),
                (
                    "emails",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="emails",
                        default=None,
                    ),
                ),
                (
                    "invitation_type",
                    sgqlc.types.Arg(InvitationType, graphql_name="invitationType", default=None),
                ),
            )
        ),
    )
    """Invite users to the account

    Arguments:

    * `auth_groups` (`[String]!`): Names of groups to add user to upon
      acceptance.
    * `emails` (`[String]!`): List of email addresses to invite
    * `invitation_type` (`InvitationType`): Type of invitation to send
      --typically maps to product.
    """

    switch_user_account = sgqlc.types.Field(
        "SwitchUserAccount",
        graphql_name="switchUserAccount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "switch_to_account_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="switchToAccountId", default=None
                    ),
                ),
                (
                    "verification_token",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="verificationToken", default=None
                    ),
                ),
            )
        ),
    )
    """User can switch accounts if provided with valid invite

    Arguments:

    * `switch_to_account_id` (`UUID!`)None
    * `verification_token` (`String!`)None
    """

    delete_user_invite = sgqlc.types.Field(
        DeleteUserInvite,
        graphql_name="deleteUserInvite",
        args=sgqlc.types.ArgDict(
            (
                (
                    "emails",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="emails",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Delete user invite

    Arguments:

    * `emails` (`[String]!`): List of email addresses to invite
    """

    resend_user_invite = sgqlc.types.Field(
        "ReInviteUsers",
        graphql_name="resendUserInvite",
        args=sgqlc.types.ArgDict(
            (
                (
                    "emails",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="emails",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Resend user invite

    Arguments:

    * `emails` (`[String]!`): List of email addresses to resend the
      invitation
    """

    remove_user_from_account = sgqlc.types.Field(
        "RemoveUserFromAccount",
        graphql_name="removeUserFromAccount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "email",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="email", default=None
                    ),
                ),
            )
        ),
    )
    """Remove user from account

    Arguments:

    * `email` (`String!`): Email address of user
    """

    disable_user = sgqlc.types.Field(
        DisableUser,
        graphql_name="disableUser",
        args=sgqlc.types.ArgDict(
            (
                (
                    "email",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="email", default=None
                    ),
                ),
            )
        ),
    )
    """Disable a user

    Arguments:

    * `email` (`String!`): Email address of user
    """

    track_table = sgqlc.types.Field(
        "TrackTablePayload",
        graphql_name="trackTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TrackTableInput), graphql_name="input", default=None
                    ),
                ),
            )
        ),
    )
    """Add table to account's dashboard

    Arguments:

    * `input` (`TrackTableInput!`)None
    """

    upload_credentials = sgqlc.types.Field(
        "UploadWarehouseCredentialsMutation",
        graphql_name="uploadCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "file",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Upload), graphql_name="file", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `file` (`Upload!`)None
    """

    save_slack_credentials = sgqlc.types.Field(
        "SaveSlackCredentialsMutation",
        graphql_name="saveSlackCredentials",
        args=sgqlc.types.ArgDict(
            (
                ("key", sgqlc.types.Arg(String, graphql_name="key", default=None)),
                (
                    "slack_app_type",
                    sgqlc.types.Arg(SlackAppType, graphql_name="slackAppType", default=None),
                ),
                (
                    "slack_installation_uuid",
                    sgqlc.types.Arg(String, graphql_name="slackInstallationUuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `key` (`String`): Slack installation UUID (deprecated, use
      slackInstallationUuid
    * `slack_app_type` (`SlackAppType`): Slack App Type
    * `slack_installation_uuid` (`String`): Slack installation UUID
    """

    deauthorize_slack_app = sgqlc.types.Field(
        DeauthorizeSlackAppMutation,
        graphql_name="deauthorizeSlackApp",
        args=sgqlc.types.ArgDict(
            (
                (
                    "slack_app_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SlackAppType),
                        graphql_name="slackAppType",
                        default=None,
                    ),
                ),
                ("team_id", sgqlc.types.Arg(String, graphql_name="teamId", default=None)),
            )
        ),
    )
    """Arguments:

    * `slack_app_type` (`SlackAppType!`): Slack App Type
    * `team_id` (`String`): Slack Team ID
    """

    test_credentials = sgqlc.types.Field(
        "TestCredentialsMutation",
        graphql_name="testCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default="bigquery"),
                ),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                ("project_id", sgqlc.types.Arg(String, graphql_name="projectId", default=None)),
            )
        ),
    )
    """Test credentials where the temp key already exists (e.g. BQ)

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `connection_type` (`String`): The type of connection to add
      (default: `"bigquery"`)
    * `key` (`String!`): Temp key from testing connections
    * `project_id` (`String`): BQ project ID if adding for a specific
      project only (lists otherwise)
    """

    test_database_credentials = sgqlc.types.Field(
        "TestDatabaseCredentials",
        graphql_name="testDatabaseCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(String, graphql_name="assumableRole", default=None),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default=None),
                ),
                ("db_name", sgqlc.types.Arg(String, graphql_name="dbName", default=None)),
                ("db_type", sgqlc.types.Arg(String, graphql_name="dbType", default=None)),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("port", sgqlc.types.Arg(Int, graphql_name="port", default=None)),
                (
                    "ssl_options",
                    sgqlc.types.Arg(SslInputOptions, graphql_name="sslOptions", default=None),
                ),
                ("user", sgqlc.types.Arg(String, graphql_name="user", default=None)),
            )
        ),
    )
    """Test a generic warehouse or database connection

    Arguments:

    * `assumable_role` (`String`): AWS role that can be assumed by the
      DC
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `connection_type` (`String`): Type of connection (e.g.
      snowflake, redshift)
    * `db_name` (`String`): Name of database to add connection for
    * `db_type` (`String`): Type of database to add connection for
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `host` (`String`): Hostname of the warehouse
    * `password` (`String`): User's password
    * `port` (`Int`): HTTP Port to use
    * `ssl_options` (`SslInputOptions`): Specify any SSL options (e.g.
      certs)
    * `user` (`String`): User with access to the database
    """

    test_presto_credentials = sgqlc.types.Field(
        "TestPrestoCredentials",
        graphql_name="testPrestoCredentials",
        args=sgqlc.types.ArgDict(
            (
                ("catalog", sgqlc.types.Arg(String, graphql_name="catalog", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
                ("http_scheme", sgqlc.types.Arg(String, graphql_name="httpScheme", default=None)),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("port", sgqlc.types.Arg(Int, graphql_name="port", default=None)),
                ("schema", sgqlc.types.Arg(String, graphql_name="schema", default=None)),
                (
                    "ssl_options",
                    sgqlc.types.Arg(SslInputOptions, graphql_name="sslOptions", default=None),
                ),
                ("user", sgqlc.types.Arg(String, graphql_name="user", default=None)),
            )
        ),
    )
    """Test connection to Presto

    Arguments:

    * `catalog` (`String`): Mount point to access data source
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `host` (`String`): Hostname
    * `http_scheme` (`String`): Scheme for authentication
    * `password` (`String`): User's password
    * `port` (`Int`): HTTP port
    * `schema` (`String`): Schema to access
    * `ssl_options` (`SslInputOptions`): Specify any ssl options
    * `user` (`String`): Username with access to catalog/schema
    """

    test_snowflake_credentials = sgqlc.types.Field(
        "TestSnowflakeCredentials",
        graphql_name="testSnowflakeCredentials",
        args=sgqlc.types.ArgDict(
            (
                ("account", sgqlc.types.Arg(String, graphql_name="account", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("oauth", sgqlc.types.Arg(OAuthConfiguration, graphql_name="oauth", default=None)),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("private_key", sgqlc.types.Arg(String, graphql_name="privateKey", default=None)),
                (
                    "private_key_passphrase",
                    sgqlc.types.Arg(String, graphql_name="privateKeyPassphrase", default=None),
                ),
                ("user", sgqlc.types.Arg(String, graphql_name="user", default=None)),
                ("warehouse", sgqlc.types.Arg(String, graphql_name="warehouse", default=None)),
            )
        ),
    )
    """Test a Snowflake connection

    Arguments:

    * `account` (`String`): Snowflake account name
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `oauth` (`OAuthConfiguration`): Configuration for OAuth for
      Snowflake.
    * `password` (`String`): User's password if using user/password
      basic auth
    * `private_key` (`String`): User's private key (base64 encoded) if
      using key pair auth.
    * `private_key_passphrase` (`String`): User's private key
      passphrase if using key pair auth. This argument is only needed
      when the private key is encrypted.
    * `user` (`String`): User with access to snowflake.
    * `warehouse` (`String`): Name of the warehouse for the user
    """

    test_hive_credentials = sgqlc.types.Field(
        "TestHiveCredentials",
        graphql_name="testHiveCredentials",
        args=sgqlc.types.ArgDict(
            (
                ("auth_mode", sgqlc.types.Arg(String, graphql_name="authMode", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("database", sgqlc.types.Arg(String, graphql_name="database", default=None)),
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
                ("port", sgqlc.types.Arg(Int, graphql_name="port", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
            )
        ),
    )
    """Test a hive sql based connection

    Arguments:

    * `auth_mode` (`String`): Authentication mode to hive. If not set
      "SASL" is used.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `database` (`String`): Name of database
    * `host` (`String`): Hostname
    * `port` (`Int`): Port
    * `username` (`String`): Username with access to hive
    """

    test_s3_credentials = sgqlc.types.Field(
        "TestS3Credentials",
        graphql_name="testS3Credentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(String, graphql_name="assumableRole", default=None),
                ),
                ("bucket", sgqlc.types.Arg(String, graphql_name="bucket", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default="s3"),
                ),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                ("prefix", sgqlc.types.Arg(String, graphql_name="prefix", default=None)),
            )
        ),
    )
    """Test a s3 based connection (e.g. presto query logs on s3)

    Arguments:

    * `assumable_role` (`String`): AWS role that can be assumed by the
      DC
    * `bucket` (`String`): S3 Bucket where relevant objects are
      contained
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `connection_type` (`String`): Type of connection (default:
      `"s3"`)
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `prefix` (`String`): Path to objects
    """

    test_glue_credentials = sgqlc.types.Field(
        "TestGlueCredentials",
        graphql_name="testGlueCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(String, graphql_name="assumableRole", default=None),
                ),
                ("aws_region", sgqlc.types.Arg(String, graphql_name="awsRegion", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                (
                    "ssl_options",
                    sgqlc.types.Arg(SslInputOptions, graphql_name="sslOptions", default=None),
                ),
            )
        ),
    )
    """Test a Glue connection

    Arguments:

    * `assumable_role` (`String`): Assumable role ARN to use for
      accessing AWS resources
    * `aws_region` (`String`): Glue region
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `ssl_options` (`SslInputOptions`): Specify any SSL options (e.g.
      certs)
    """

    test_athena_credentials = sgqlc.types.Field(
        "TestAthenaCredentials",
        graphql_name="testAthenaCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(String, graphql_name="assumableRole", default=None),
                ),
                ("aws_region", sgqlc.types.Arg(String, graphql_name="awsRegion", default=None)),
                ("catalog", sgqlc.types.Arg(String, graphql_name="catalog", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                ("workgroup", sgqlc.types.Arg(String, graphql_name="workgroup", default=None)),
            )
        ),
    )
    """Test an Athena connection

    Arguments:

    * `assumable_role` (`String`): Assumable role ARN to use for
      accessing AWS resources
    * `aws_region` (`String`): Athena cluster region
    * `catalog` (`String`): Glue data catalog
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `workgroup` (`String`): Workbook for running queries and
      retrieving logs. If not specified the primary is used
    """

    test_looker_git_credentials = sgqlc.types.Field(
        "TestLookerGitCredentials",
        graphql_name="testLookerGitCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "installation_id",
                    sgqlc.types.Arg(Int, graphql_name="installationId", default=None),
                ),
            )
        ),
    )
    """Deprecated. Do not use.

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `installation_id` (`Int`): ID response from Github
    """

    test_looker_git_clone_credentials = sgqlc.types.Field(
        "TestLookerGitCloneCredentials",
        graphql_name="testLookerGitCloneCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("repo_url", sgqlc.types.Arg(String, graphql_name="repoUrl", default=None)),
                ("ssh_key", sgqlc.types.Arg(String, graphql_name="sshKey", default=None)),
                ("token", sgqlc.types.Arg(String, graphql_name="token", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
            )
        ),
    )
    """Test the connection to a Git repository using the SSH or HTTPS
    protocol

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `repo_url` (`String`): Repository URL as
      ssh://[user@]server/project.git or the shorter form
      [user@]server:project.git SSH integrations and
      htts://server/project.git for HTTPS integrations
    * `ssh_key` (`String`): SSH key, base64-encoded
    * `token` (`String`): The access token for git HTTPS integrations
    * `username` (`String`): The git username for BitBucket
      integrations
    """

    test_dbt_cloud_credentials = sgqlc.types.Field(
        "TestDbtCloudCredentials",
        graphql_name="testDbtCloudCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        String, graphql_name="connectionType", default="dbt-cloud-webhook"
                    ),
                ),
                (
                    "dbt_cloud_account_id",
                    sgqlc.types.Arg(String, graphql_name="dbtCloudAccountId", default=None),
                ),
                (
                    "dbt_cloud_api_token",
                    sgqlc.types.Arg(String, graphql_name="dbtCloudApiToken", default=None),
                ),
                (
                    "dbt_cloud_base_url",
                    sgqlc.types.Arg(String, graphql_name="dbtCloudBaseUrl", default=None),
                ),
                (
                    "dbt_cloud_webhook_hmac_secret",
                    sgqlc.types.Arg(String, graphql_name="dbtCloudWebhookHmacSecret", default=None),
                ),
                (
                    "dbt_cloud_webhook_id",
                    sgqlc.types.Arg(String, graphql_name="dbtCloudWebhookId", default=None),
                ),
            )
        ),
    )
    """Test a dbt Cloud connection

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `connection_type` (`String`): dbt Cloud connection type
      (default: `"dbt-cloud-webhook"`)
    * `dbt_cloud_account_id` (`String`): dbt Cloud account ID
    * `dbt_cloud_api_token` (`String`): dbt Cloud API token
    * `dbt_cloud_base_url` (`String`): dbt Cloud base URL
    * `dbt_cloud_webhook_hmac_secret` (`String`): Provide the
      hmac_secret of a dbt outbound webhook to setup a webhook-based
      dbt integration
    * `dbt_cloud_webhook_id` (`String`): Provide the webhook ID of a
      dbt outbound webhook to setup a webhook-based dbt integration
    """

    test_bq_credentials = sgqlc.types.Field(
        "TestBqCredentials",
        graphql_name="testBqCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("service_json", sgqlc.types.Arg(String, graphql_name="serviceJson", default=None)),
            )
        ),
    )
    """Test a BQ connection

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `service_json` (`String`): Service account key file as a base64
      string
    """

    test_spark_credentials = sgqlc.types.Field(
        "TestSparkCredentials",
        graphql_name="testSparkCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "binary_mode",
                    sgqlc.types.Arg(SparkBinaryInput, graphql_name="binaryMode", default=None),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "http_mode",
                    sgqlc.types.Arg(SparkHttpInput, graphql_name="httpMode", default=None),
                ),
            )
        ),
    )
    """Test Spark credentials

    Arguments:

    * `binary_mode` (`SparkBinaryInput`): Configuration for Thrift in
      binary mode
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `http_mode` (`SparkHttpInput`): Configuration for Thrift in HTTP
      mode
    """

    test_databricks_sql_warehouse_credentials = sgqlc.types.Field(
        "TestDatabricksSqlWarehouseCredentials",
        graphql_name="testDatabricksSqlWarehouseCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "databricks_config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatabricksSqlWarehouseInput),
                        graphql_name="databricksConfig",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Test Databricks Sql Warehouse credentials

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `databricks_config` (`DatabricksSqlWarehouseInput!`):
      Configuration for the Databricks sql warehouse.
    """

    test_self_hosted_credentials = sgqlc.types.Field(
        "TestSelfHostedCredentials",
        graphql_name="testSelfHostedCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(String, graphql_name="assumableRole", default=None),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default=None),
                ),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                ("region", sgqlc.types.Arg(String, graphql_name="region", default=None)),
                (
                    "self_hosting_key",
                    sgqlc.types.Arg(String, graphql_name="selfHostingKey", default=None),
                ),
                (
                    "self_hosting_mechanism",
                    sgqlc.types.Arg(String, graphql_name="selfHostingMechanism", default=None),
                ),
            )
        ),
    )
    """Test a connection of any type with self-hosted credentials.

    Arguments:

    * `assumable_role` (`String`): Role that can be assumed by the DC
      to access the self-hosting mechanism
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `connection_type` (`String`): Type of connection
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `region` (`String`): Region where the credentials are hosted
    * `self_hosting_key` (`String`): Identifier for the credentials
      within the self-hosting mechanism (e.g. SecretManager secret
      ARN)
    * `self_hosting_mechanism` (`String`): Type of credential self-
      hosting mechanism
    """

    test_tableau_credentials = sgqlc.types.Field(
        "TestTableauCredentialsMutation",
        graphql_name="testTableauCredentials",
        args=sgqlc.types.ArgDict(
            (
                ("client_id", sgqlc.types.Arg(String, graphql_name="clientId", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("secret_id", sgqlc.types.Arg(String, graphql_name="secretId", default=None)),
                ("secret_value", sgqlc.types.Arg(String, graphql_name="secretValue", default=None)),
                (
                    "server_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverName", default=None
                    ),
                ),
                ("site_name", sgqlc.types.Arg(String, graphql_name="siteName", default=None)),
                ("token_name", sgqlc.types.Arg(String, graphql_name="tokenName", default=None)),
                ("token_value", sgqlc.types.Arg(String, graphql_name="tokenValue", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                ("verify_ssl", sgqlc.types.Arg(Boolean, graphql_name="verifySsl", default=True)),
            )
        ),
    )
    """Test Tableau credentials

    Arguments:

    * `client_id` (`String`): The Tableau Connected Apps Client ID
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `password` (`String`): Password for the Tableau user if using
      username/password
    * `secret_id` (`String`): The Tableau Connected Apps Secret ID
    * `secret_value` (`String`): The Tableau Connected Apps Secret
      value
    * `server_name` (`String!`): The Tableau server name
    * `site_name` (`String`): The Tableau site name
    * `token_name` (`String`): The personal access token name for PAT
      authentication
    * `token_value` (`String`): The personal access token value for
      PAT authentication
    * `username` (`String`): Username for the Tableau user if using
      username/password or Connected Apps
    * `verify_ssl` (`Boolean`): Whether to verify the SSL connection
      to Tableau server (default: `true`)
    """

    test_power_bi_credentials = sgqlc.types.Field(
        "TestPowerBICredentials",
        graphql_name="testPowerBiCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "auth_mode",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(PowerBIAuthModeEnum),
                        graphql_name="authMode",
                        default=None,
                    ),
                ),
                (
                    "client_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="clientId", default=None
                    ),
                ),
                (
                    "client_secret",
                    sgqlc.types.Arg(String, graphql_name="clientSecret", default=None),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                (
                    "tenant_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tenantId", default=None
                    ),
                ),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
            )
        ),
    )
    """Test Power BI credentials

    Arguments:

    * `auth_mode` (`PowerBIAuthModeEnum!`): Authentication mode. We
      support two values here [service_principal, primary_user]
    * `client_id` (`String!`): App Client uuid
    * `client_secret` (`String`): Secret key for the client ID.
      Required if auth_mode is service_principal.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `password` (`String`): Password when auth as a primary user.
      Required if auth_mode is primary_user.
    * `tenant_id` (`String!`): Azure power bi tenant uuid
    * `username` (`String`): Username when auth as a primary user.
      Required if auth_mode is primary_user.
    """

    test_fivetran_credentials = sgqlc.types.Field(
        "TestFivetranCredentials",
        graphql_name="testFivetranCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "fivetran_api_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="fivetranApiKey", default=None
                    ),
                ),
                (
                    "fivetran_api_password",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="fivetranApiPassword",
                        default=None,
                    ),
                ),
                (
                    "fivetran_base_url",
                    sgqlc.types.Arg(String, graphql_name="fivetranBaseUrl", default=None),
                ),
            )
        ),
    )
    """Test Fivetran credentials

    Arguments:

    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests
    * `fivetran_api_key` (`String!`): Fivetran API Key
    * `fivetran_api_password` (`String!`): Fivetran API Password
    * `fivetran_base_url` (`String`): Fivetran base URL
    """

    toggle_mute_dataset = sgqlc.types.Field(
        "ToggleMuteDatasetPayload",
        graphql_name="toggleMuteDataset",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ToggleMuteDatasetInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(Deprecated) Start/Stop creating incidents for the given dataset

    Arguments:

    * `input` (`ToggleMuteDatasetInput!`)None
    """

    toggle_mute_table = sgqlc.types.Field(
        "ToggleMuteTablePayload",
        graphql_name="toggleMuteTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ToggleMuteTableInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(Deprecated) Start/Stop creating incidents for the given table

    Arguments:

    * `input` (`ToggleMuteTableInput!`)None
    """

    toggle_mute_datasets = sgqlc.types.Field(
        "ToggleMuteDatasetsPayload",
        graphql_name="toggleMuteDatasets",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ToggleMuteDatasetsInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(Deprecated) Start/Stop creating incidents for the given datasets

    Arguments:

    * `input` (`ToggleMuteDatasetsInput!`)None
    """

    toggle_mute_tables = sgqlc.types.Field(
        "ToggleMuteTablesPayload",
        graphql_name="toggleMuteTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ToggleMuteTablesInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(Deprecated) Start/Stop creating incidents for the given tables

    Arguments:

    * `input` (`ToggleMuteTablesInput!`)None
    """

    toggle_mute_with_regex = sgqlc.types.Field(
        "ToggleMuteWithRegexPayload",
        graphql_name="toggleMuteWithRegex",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ToggleMuteWithRegexInput),
                        graphql_name="input",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. End of life: August 01, 2025. Toggle
    mute for a set of tables and datasets.

    Arguments:

    * `input` (`ToggleMuteWithRegexInput!`)None
    """

    toggle_slack_reply_warning = sgqlc.types.Field(
        "ToggleSlackReplyWarning",
        graphql_name="toggleSlackReplyWarning",
        args=sgqlc.types.ArgDict(
            (
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
                ("team_id", sgqlc.types.Arg(String, graphql_name="teamId", default=None)),
            )
        ),
    )
    """Enable/disable the Slack reply warning feature

    Arguments:

    * `enable` (`Boolean!`): If true, enable the feature
    * `team_id` (`String`): Slack Team ID
    """

    toggle_slack_broadcast_updates = sgqlc.types.Field(
        "ToggleSlackBroadcastUpdates",
        graphql_name="toggleSlackBroadcastUpdates",
        args=sgqlc.types.ArgDict(
            (
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
                ("team_id", sgqlc.types.Arg(String, graphql_name="teamId", default=None)),
            )
        ),
    )
    """(experimental) Enable/disable posting alert/incident updates to
    Slack channel in addition to posting a thread reply to the
    original message.

    Arguments:

    * `enable` (`Boolean!`): If true, enable the feature
    * `team_id` (`String`): Slack Team ID
    """

    toggle_connection_enable = sgqlc.types.Field(
        "ToggleConnectionEnable",
        graphql_name="toggleConnectionEnable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
            )
        ),
    )
    """Enable or Disable a connection. This will also skip/un-skip all
    related data collector schedules.

    Arguments:

    * `connection_id` (`UUID!`): Connection to perform the action on
    * `enable` (`Boolean!`): Indicates whether the connection should
      be enabled (true) or disabled (false)
    """

    add_connection = sgqlc.types.Field(
        AddConnectionMutation,
        graphql_name="addConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_name",
                    sgqlc.types.Arg(String, graphql_name="connectionName", default=None),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                (
                    "create_warehouse_type",
                    sgqlc.types.Arg(String, graphql_name="createWarehouseType", default=None),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("is_active", sgqlc.types.Arg(Boolean, graphql_name="isActive", default=True)),
                ("job_limits", sgqlc.types.Arg(JSONString, graphql_name="jobLimits", default=None)),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
            )
        ),
    )
    """Add a connection and setup any associated jobs. Creates a
    warehouse if not specified

    Arguments:

    * `connection_name` (`String`): Provide a friendly name for the
      connection when creating
    * `connection_type` (`String!`): The type of connection to add
    * `create_warehouse_type` (`String`): Create a new warehouse for
      the connection
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `dw_id` (`UUID`): Add connection to an existing warehouse
    * `is_active` (`Boolean`): Set the connection to active or
      inactive (default: true) (default: `true`)
    * `job_limits` (`JSONString`): Customize job operations for all
      job types
    * `job_types` (`[String]`): Specify job types for the connection.
      Uses connection default otherwise
    * `key` (`String!`): Temp key from testing connections
    * `name` (`String`): Provide a friendly name for the warehouse
      when creating
    """

    add_redshift_consumer_connection = sgqlc.types.Field(
        AddRedshiftConsumerConnectionMutation,
        graphql_name="addRedshiftConsumerConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_name",
                    sgqlc.types.Arg(String, graphql_name="connectionName", default=None),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("is_active", sgqlc.types.Arg(Boolean, graphql_name="isActive", default=True)),
                ("job_limits", sgqlc.types.Arg(JSONString, graphql_name="jobLimits", default=None)),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                (
                    "producer_resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="producerResourceId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Add a Redshift Consumer connection for datashare
    lineage.

    Arguments:

    * `connection_name` (`String`): Provide a friendly name for the
      consumer connection when creating
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `is_active` (`Boolean`): Set the connection to active or
      inactive (default: true) (default: `true`)
    * `job_limits` (`JSONString`): Customize job operations for all
      job types
    * `job_types` (`[String]`): Specify job types for the connection.
      Uses connection default otherwise
    * `key` (`String!`): Temp key from testing connections
    * `producer_resource_id` (`UUID!`): The warehouse UUID of the
      parent Redshift warehouse.
    """

    remove_connection = sgqlc.types.Field(
        "RemoveConnectionMutation",
        graphql_name="removeConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Remove an integration connection and deschedule any associated
    jobs

    Arguments:

    * `connection_id` (`UUID!`): ID of the connection to remove
    """

    set_connection_deletion_protection = sgqlc.types.Field(
        "SetConnectionDeletionProtectionMutation",
        graphql_name="setConnectionDeletionProtection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "enable_deletion_protection",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="enableDeletionProtection",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Enable/disable deletion protection for a
    connection. Protected connections cannot be deleted.

    Arguments:

    * `connection_id` (`UUID!`): ID of the connection to set deletion
      protection
    * `enable_deletion_protection` (`Boolean!`): Enable or disable
      deletion protection
    """

    add_bi_connection = sgqlc.types.Field(
        AddBiConnectionMutation,
        graphql_name="addBiConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_name",
                    sgqlc.types.Arg(String, graphql_name="connectionName", default=None),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
            )
        ),
    )
    """Add a bi connection and setup any associated jobs

    Arguments:

    * `connection_name` (`String`): Provide a friendly name for the BI
      connection.
    * `connection_type` (`String!`): The type of connection to add
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `job_types` (`[String]`): Specify job types for the connection.
      Uses connection default otherwise
    * `key` (`String!`): Temp key from testing connections
    * `name` (`String`): Provide a friendly name for the BI
      integration.
    * `resource_id` (`UUID`): BI Container UUID. Add the connection
      under the same resource UUID.
    """

    update_bi_connection_name = sgqlc.types.Field(
        "UpdateBiConnectionNameMutation",
        graphql_name="updateBiConnectionName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
            )
        ),
    )
    """Update the name of an existing BI integration.

    Arguments:

    * `name` (`String!`): Provide a friendly name for the BI
      integration.
    * `resource_id` (`UUID!`): Existing BI Container UUID.
    """

    add_etl_connection = sgqlc.types.Field(
        AddEtlConnectionMutation,
        graphql_name="addEtlConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_name",
                    sgqlc.types.Arg(String, graphql_name="connectionName", default=None),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """Add an etl connection and setup any associated jobs

    Arguments:

    * `connection_name` (`String`): Provide a friendly name for the
      ETL connection
    * `connection_type` (`String!`): The type of connection to add
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `key` (`String!`): Temp key from testing connections
    * `name` (`String!`): Provide a friendly name for the ETL
      integration.
    """

    toggle_event_config = sgqlc.types.Field(
        "ToggleEventConfig",
        graphql_name="toggleEventConfig",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(String, graphql_name="assumableRole", default=None),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default=None),
                ),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "enable",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="enable", default=None
                    ),
                ),
                (
                    "event_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataCollectorEventTypes),
                        graphql_name="eventType",
                        default=None,
                    ),
                ),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                ("format_type", sgqlc.types.Arg(String, graphql_name="formatType", default=None)),
                ("location", sgqlc.types.Arg(String, graphql_name="location", default=None)),
                ("mapping", sgqlc.types.Arg(JSONString, graphql_name="mapping", default=None)),
                (
                    "source_format",
                    sgqlc.types.Arg(String, graphql_name="sourceFormat", default=None),
                ),
            )
        ),
    )
    """Enable / disable the configuration for data collection via events

    Arguments:

    * `assumable_role` (`String`): AWS role that can be assumed by the
      DC
    * `connection_id` (`UUID`): The connection id. Cannot be present
      with DW ID
    * `connection_type` (`String`): Type of connection (e.g. hive-s3),
      required if connection id not set
    * `dw_id` (`UUID`): The warehouse id. Cannot be present with
      connection ID
    * `enable` (`Boolean!`): If true enable the connection, otherwise
      disable it
    * `event_type` (`DataCollectorEventTypes!`): Type of event (e.g.
      metadata)
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `format_type` (`String`): Log file format (e.g. hive-emr)
    * `location` (`String`): Location of the log files
    * `mapping` (`JSONString`): A map where keys are the attributes in
      the destinationschema and values are the keys in the source
      schema
    * `source_format` (`String`): File format (e.g. "json")
    """

    configure_metadata_events = sgqlc.types.Field(
        ConfigureMetadataEvents,
        graphql_name="configureMetadataEvents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
            )
        ),
    )
    """Configure collection of metadata via S3 events

    Arguments:

    * `connection_type` (`String!`): Type of data lake connection
      (e.g. hive-s3)
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `name` (`String`): Provide a friendly name for the warehouse
      when creating
    """

    configure_query_log_events = sgqlc.types.Field(
        ConfigureQueryLogEvents,
        graphql_name="configureQueryLogEvents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "assumable_role",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="assumableRole", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("external_id", sgqlc.types.Arg(String, graphql_name="externalId", default=None)),
                (
                    "format_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="formatType", default=None
                    ),
                ),
                ("location", sgqlc.types.Arg(String, graphql_name="location", default=None)),
                ("mapping", sgqlc.types.Arg(JSONString, graphql_name="mapping", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                (
                    "source_format",
                    sgqlc.types.Arg(String, graphql_name="sourceFormat", default=None),
                ),
            )
        ),
    )
    """Configure collection of query logs via S3 events

    Arguments:

    * `assumable_role` (`String!`): AWS role that can be assumed by
      the DC
    * `connection_type` (`String!`): Type of data lake connection
      (e.g. hive-s3)
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `external_id` (`String`): An external id, per assumable role
      conditions
    * `format_type` (`String!`): Log file format (e.g. hive-emr)
    * `location` (`String`): Location of the log files
    * `mapping` (`JSONString`): A map where keys are the attributes in
      the destinationschema and values are the keys in the source
      schema
    * `name` (`String`): Provide a friendly name for the warehouse
      when creating
    * `source_format` (`String`): File format (e.g. "json")
    """

    disable_metadata_events = sgqlc.types.Field(
        DisableMetadataEvents,
        graphql_name="disableMetadataEvents",
        args=sgqlc.types.ArgDict(
            (("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),)
        ),
    )
    """Disable collection of metadata via S3 events

    Arguments:

    * `name` (`String`): Resource name (required if more than one is
      present
    """

    disable_query_log_events = sgqlc.types.Field(
        DisableQueryLogEvents,
        graphql_name="disableQueryLogEvents",
        args=sgqlc.types.ArgDict(
            (
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
            )
        ),
    )
    """Disable collection of query logs via S3 events

    Arguments:

    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `name` (`String`): Resource name (required if more than one is
      present
    """

    create_or_update_service_api_token = sgqlc.types.Field(
        CreateOrUpdateServiceApiToken,
        graphql_name="createOrUpdateServiceApiToken",
        args=sgqlc.types.ArgDict(
            (
                ("comment", sgqlc.types.Arg(String, graphql_name="comment", default=None)),
                ("display_name", sgqlc.types.Arg(String, graphql_name="displayName", default=None)),
                (
                    "expiration_in_days",
                    sgqlc.types.Arg(Int, graphql_name="expirationInDays", default=None),
                ),
                (
                    "groups",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="groups", default=None
                    ),
                ),
                ("token_id", sgqlc.types.Arg(String, graphql_name="tokenId", default=None)),
            )
        ),
    )
    """Generate a service API Access Token

    Arguments:

    * `comment` (`String`): Any comment or description to help
      identify the token
    * `display_name` (`String`): A name to show when displaying the
      user name
    * `expiration_in_days` (`Int`): Number of days before the token
      auto expires
    * `groups` (`[String]`): Names of the groups for the API token.
    * `token_id` (`String`): Token ID to edit
    """

    create_access_token = sgqlc.types.Field(
        CreateAccessToken,
        graphql_name="createAccessToken",
        args=sgqlc.types.ArgDict(
            (
                ("comment", sgqlc.types.Arg(String, graphql_name="comment", default=None)),
                (
                    "expiration_in_days",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="expirationInDays", default=None
                    ),
                ),
            )
        ),
    )
    """Generate an API Access Token and associate to user

    Arguments:

    * `comment` (`String`): Any comment or description to help
      identify the token
    * `expiration_in_days` (`Int!`): Number of days before the token
      auto expires
    """

    delete_access_token = sgqlc.types.Field(
        DeleteAccessToken,
        graphql_name="deleteAccessToken",
        args=sgqlc.types.ArgDict(
            (
                (
                    "token_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tokenId", default=None
                    ),
                ),
            )
        ),
    )
    """Delete an API Access Token by ID

    Arguments:

    * `token_id` (`String!`): ID of the token to delete
    """

    generate_collector_template = sgqlc.types.Field(
        GenerateCollectorTemplate,
        graphql_name="generateCollectorTemplate",
        args=sgqlc.types.ArgDict(
            (
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("region", sgqlc.types.Arg(String, graphql_name="region", default="us-east-1")),
                (
                    "template_variant",
                    sgqlc.types.Arg(String, graphql_name="templateVariant", default=None),
                ),
                (
                    "update_infra",
                    sgqlc.types.Arg(Boolean, graphql_name="updateInfra", default=False),
                ),
            )
        ),
    )
    """Generate a data collector template (uploaded to S3)

    Arguments:

    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `region` (`String`): Region where the DC is hosted (default:
      `"us-east-1"`)
    * `template_variant` (`String`): DC template variant.
    * `update_infra` (`Boolean`): Use latest version of the collector
      template, with any infrastructure changes it might include.
      Otherwise, only the lambda code version will be updated.
      (default: `false`)
    """

    update_credentials = sgqlc.types.Field(
        "UpdateCredentials",
        graphql_name="updateCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "changes",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JSONString), graphql_name="changes", default=None
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "should_replace",
                    sgqlc.types.Arg(Boolean, graphql_name="shouldReplace", default=False),
                ),
                (
                    "should_validate",
                    sgqlc.types.Arg(Boolean, graphql_name="shouldValidate", default=True),
                ),
            )
        ),
    )
    """Update credentials for a connection

    Arguments:

    * `changes` (`JSONString!`): JSON Key/values with fields to update
    * `connection_id` (`UUID!`): ID for connection to update
    * `should_replace` (`Boolean`): Set true to replace all
      credentials with changes. Otherwise inserts/replaces (default:
      `false`)
    * `should_validate` (`Boolean`): Set to true to test changes
      before saving (default: `true`)
    """

    create_collector_record = sgqlc.types.Field(
        CreateCollectorRecord,
        graphql_name="createCollectorRecord",
        args=sgqlc.types.ArgDict(
            (
                ("region", sgqlc.types.Arg(String, graphql_name="region", default="us-east-1")),
                (
                    "template_provider",
                    sgqlc.types.Arg(
                        String, graphql_name="templateProvider", default="cloudformation"
                    ),
                ),
                (
                    "template_variant",
                    sgqlc.types.Arg(String, graphql_name="templateVariant", default="janus"),
                ),
            )
        ),
    )
    """Create an additional collector record (with template) in the
    account.

    Arguments:

    * `region` (`String`): Region where the DC is hosted (default:
      `"us-east-1"`)
    * `template_provider` (`String`): DC template IaC provider
      (default: `"cloudformation"`)
    * `template_variant` (`String`): DC template variant (default:
      `"janus"`)
    """

    cleanup_collector_record = sgqlc.types.Field(
        CleanupCollectorRecordInAccount,
        graphql_name="cleanupCollectorRecord",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dc_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dcId", default=None),
                ),
            )
        ),
    )
    """Deletes an unassociated collector record in the account. This does
    not delete the CloudFormation stack and will not succeed if the
    collector is active and/or associated with a warehouse.

    Arguments:

    * `dc_id` (`UUID!`): DC UUID
    """

    migrate_collector_resources = sgqlc.types.Field(
        MigrateCollectorResources,
        graphql_name="migrateCollectorResources",
        args=sgqlc.types.ArgDict(
            (
                (
                    "overrides",
                    sgqlc.types.Arg(GenericScalar, graphql_name="overrides", default=None),
                ),
                (
                    "resource_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="resourceIds", default=None
                    ),
                ),
                (
                    "source_dc_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="sourceDcId", default=None
                    ),
                ),
                (
                    "target_dc_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="targetDcId", default=None
                    ),
                ),
            )
        ),
    )
    """Migrate resources (warehouses, BI) from one data collector to
    another

    Arguments:

    * `overrides` (`GenericScalar`): Dictionary containing properties
      to override per connection. The key must be the connection UUID
      and the value a dictionary including new values for the
      connection properties, like 'host'.
    * `resource_ids` (`[UUID]`): List of resource UUIDs to migrate. By
      default all resources will be migrated.
    * `source_dc_id` (`UUID!`): Source DC UUID
    * `target_dc_id` (`UUID!`): Target DC UUID
    """

    update_slack_channels = sgqlc.types.Field(
        "UpdateSlackChannelsMutation", graphql_name="updateSlackChannels"
    )
    """Update the slack channels cache for the account"""

    create_integration_key = sgqlc.types.Field(
        CreateIntegrationKey,
        graphql_name="createIntegrationKey",
        args=sgqlc.types.ArgDict(
            (
                (
                    "description",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="description", default=None
                    ),
                ),
                (
                    "scope",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(IntegrationKeyScope),
                        graphql_name="scope",
                        default=None,
                    ),
                ),
                (
                    "warehouse_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="warehouseIds", default=None
                    ),
                ),
            )
        ),
    )
    """Create an integration key

    Arguments:

    * `description` (`String!`): Key description
    * `scope` (`IntegrationKeyScope!`): Key scope (integration it can
      be used for)
    * `warehouse_ids` (`[UUID]`): UUID(s) of warehouse(s) associated
      with key
    """

    delete_integration_key = sgqlc.types.Field(
        DeleteIntegrationKey,
        graphql_name="deleteIntegrationKey",
        args=sgqlc.types.ArgDict(
            (
                (
                    "key_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="keyId", default=None
                    ),
                ),
            )
        ),
    )
    """Delete an integration key

    Arguments:

    * `key_id` (`String!`): Integration key id
    """

    start_databricks_warehouse = sgqlc.types.Field(
        "StartDatabricksWarehouse",
        graphql_name="startDatabricksWarehouse",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_config",
                    sgqlc.types.Arg(
                        DatabricksSqlWarehouseConnectionInput,
                        graphql_name="connectionConfig",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
            )
        ),
    )
    """Start Databricks Warehouse.

    Arguments:

    * `connection_config` (`DatabricksSqlWarehouseConnectionInput`):
      Connection config for new Databricks SQL warehouse connection
    * `connection_id` (`UUID`): A Databricks connection UUID
    """

    add_databricks_connection = sgqlc.types.Field(
        AddDatabricksConnectionMutation,
        graphql_name="addDatabricksConnection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_name",
                    sgqlc.types.Arg(String, graphql_name="connectionName", default=None),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                (
                    "create_warehouse_type",
                    sgqlc.types.Arg(String, graphql_name="createWarehouseType", default=None),
                ),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "job_limits",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JSONString), graphql_name="jobLimits", default=None
                    ),
                ),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
            )
        ),
    )
    """Add a databricks connection and setup any associated jobs. Creates
    a warehouse if not specified

    Arguments:

    * `connection_name` (`String`): Provide a friendly name for the
      connection being added to the integration
    * `connection_type` (`String!`): The type of connection to add
    * `create_warehouse_type` (`String`): Create a new warehouse for
      the connection
    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors
    * `dw_id` (`UUID`): Add connection to an existing warehouse
    * `job_limits` (`JSONString!`): Customize job operations for all
      job types
    * `job_types` (`[String]`): Specify job types for the connection.
      Uses connection default otherwise
    * `key` (`String!`): Temp key from testing connections
    * `name` (`String`): Provide a friendly name for the integration
      when creating
    """

    save_event_onboarding_data = sgqlc.types.Field(
        "SaveEventOnboardingData",
        graphql_name="saveEventOnboardingData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JSONString), graphql_name="config", default=None
                    ),
                ),
            )
        ),
    )
    """Save event onboarding configuration

    Arguments:

    * `config` (`JSONString!`): JSON Key/values with event config to
      store
    """

    delete_event_onboarding_data = sgqlc.types.Field(
        DeleteEventOnboardingData, graphql_name="deleteEventOnboardingData"
    )
    """Delete stored event onboarding configuration"""

    toggle_account_feature = sgqlc.types.Field(
        "ToggleAccountFeature",
        graphql_name="toggleAccountFeature",
        args=sgqlc.types.ArgDict(
            (
                (
                    "feature",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="feature", default=None
                    ),
                ),
                (
                    "is_enabled",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="isEnabled", default=None
                    ),
                ),
            )
        ),
    )
    """Enable/disable an account level feature

    Arguments:

    * `feature` (`String!`): Feature to enable/disable
    * `is_enabled` (`Boolean!`): Enable or disable the feature
    """

    set_tutorial_state = sgqlc.types.Field(
        "SetTutorialState",
        graphql_name="setTutorialState",
        args=sgqlc.types.ArgDict(
            (
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TutorialStatusType), graphql_name="state", default=None
                    ),
                ),
                (
                    "tutorial_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tutorialName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Sets the state of a tutorial

    Arguments:

    * `state` (`TutorialStatusType!`): initial, started, completed,
      invalid
    * `tutorial_name` (`String!`): The name of the tutorial which
      includes the step
    """

    set_data_lake_catalog_mappings = sgqlc.types.Field(
        "SetDataLakeCatalogMappings",
        graphql_name="setDataLakeCatalogMappings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionUuid", default=None
                    ),
                ),
                (
                    "database_mappings",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CatalogMappingInput)),
                        graphql_name="databaseMappings",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Sets the catalog mappings for a given connection.

    Arguments:

    * `connection_uuid` (`UUID!`): connection id
    * `database_mappings` (`[CatalogMappingInput]!`): List of catalog
      object name mappings
    """

    delete_integration = sgqlc.types.Field(
        DeleteIntegrationMutation,
        graphql_name="deleteIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Deletes an integration and it's connections

    Arguments:

    * `integration_id` (`UUID!`): ID of the integration to delete
    """

    update_workspace_identifier = sgqlc.types.Field(
        "UpdateWorkspaceIdentifier",
        graphql_name="updateWorkspaceIdentifier",
        args=sgqlc.types.ArgDict(
            (
                (
                    "value",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="value", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Updates the workspace identifier for this account

    Arguments:

    * `value` (`String!`): A new workspace identifier
    """

    update_statement_option = sgqlc.types.Field(
        "UpdateStatementOption",
        graphql_name="updateStatementOption",
        args=sgqlc.types.ArgDict(
            (
                (
                    "emails",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="emails", default=None
                    ),
                ),
                (
                    "option",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(StatementOption), graphql_name="option", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Update the account's statement option

    Arguments:

    * `emails` (`[String]`): Required when option is
      SPECIFIC_ADDRESSES
    * `option` (`StatementOption!`)None
    """

    update_daily_usage_alert_config = sgqlc.types.Field(
        "UpdateDailyUsageAlertConfig",
        graphql_name="updateDailyUsageAlertConfig",
        args=sgqlc.types.ArgDict(
            (
                (
                    "usage_alert_config",
                    sgqlc.types.Arg(
                        UsageAlertConfigInput, graphql_name="usageAlertConfig", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Update the account's daily usage alerts config

    Arguments:

    * `usage_alert_config` (`UsageAlertConfigInput`)None
    """

    test_snowflake_credentials_v2 = sgqlc.types.Field(
        "TestSnowflakeCredentialsV2",
        graphql_name="testSnowflakeCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SnowflakeConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Snowflake credentials

    Arguments:

    * `connection_details` (`SnowflakeConnectionDetails!`): Connection
      parameters.
    * `connection_id` (`UUID`): If updating an existing connection,
      the ID of the connection to test.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_redshift_credentials_v2 = sgqlc.types.Field(
        "TestRedshiftCredentialsV2",
        graphql_name="testRedshiftCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(RedshiftConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Redshift credentials

    Arguments:

    * `connection_details` (`RedshiftConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_bq_credentials_v2 = sgqlc.types.Field(
        "TestBqCredentialsV2",
        graphql_name="testBqCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(BqConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test BigQuery credentials

    Arguments:

    * `connection_details` (`BqConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_tableau_credentials_v2 = sgqlc.types.Field(
        "TestTableauCredentialsV2",
        graphql_name="testTableauCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TableauConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Tableau credentials

    Arguments:

    * `connection_details` (`TableauConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_looker_credentials_v2 = sgqlc.types.Field(
        "TestLookerCredentialsV2",
        graphql_name="testLookerCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LookerConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Looker API credentials

    Arguments:

    * `connection_details` (`LookerConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_looker_git_clone_credentials_v2 = sgqlc.types.Field(
        "TestLookerGitCloneCredentialsV2",
        graphql_name="testLookerGitCloneCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LookerGitCloneConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test the connection to a Git repository using the HTTPS protocol

    Arguments:

    * `connection_details` (`LookerGitCloneConnectionDetails!`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_looker_git_auth_credentials_v2 = sgqlc.types.Field(
        "TestLookerGitAuthCredentialsV2",
        graphql_name="testLookerGitAuthCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LookerGitAuthConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Test the connection to a Git repository using the
    HTTPS or SSH protocol

    Arguments:

    * `connection_details` (`LookerGitAuthConnectionDetails!`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_power_bi_credentials_v2 = sgqlc.types.Field(
        "TestPowerBICredentialsV2",
        graphql_name="testPowerBiCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(PowerBIConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Databricks SQL Warehouse credentials

    Arguments:

    * `connection_details` (`PowerBIConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_databricks_sql_warehouse_credentials_v2 = sgqlc.types.Field(
        "TestDatabricksSqlWarehouseCredentialsV2",
        graphql_name="testDatabricksSqlWarehouseCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatabricksSqlWarehouseInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Power BI credentials

    Arguments:

    * `connection_details` (`DatabricksSqlWarehouseInput!`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_databricks_metastore_sql_warehouse_credentials_v2 = sgqlc.types.Field(
        "TestDatabricksMetastoreSqlWarehouseCredentialsV2",
        graphql_name="testDatabricksMetastoreSqlWarehouseCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatabricksSqlWarehouseInput),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Databricks Metastore Sql Warehouse credentials

    Arguments:

    * `connection_details` (`DatabricksSqlWarehouseInput!`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_airflow_credentials_v2 = sgqlc.types.Field(
        "TestAirflowCredentialsV2",
        graphql_name="testAirflowCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AirflowConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Airflow credentials

    Arguments:

    * `connection_details` (`AirflowConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_pinecone_credentials = sgqlc.types.Field(
        "TestPineconeCredentials",
        graphql_name="testPineconeCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(PineconeConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Pinecone credentials

    Arguments:

    * `connection_details` (`PineconeConnectionDetails!`): Connection
      parameters for Pinecone.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_transactional_db_credentials = sgqlc.types.Field(
        "TestTransactionalDbCredentialsV2",
        graphql_name="testTransactionalDbCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TransactionalDbConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """Test Transactional DB credentials

    Arguments:

    * `connection_details` (`TransactionalDbConnectionDetails!`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_informatica_credentials = sgqlc.types.Field(
        "TestInformaticaCredentials",
        graphql_name="testInformaticaCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(InformaticaConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Test Informatica credentials

    Arguments:

    * `connection_details` (`InformaticaConnectionDetails!`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_azure_data_factory_credentials = sgqlc.types.Field(
        "TestAzureDataFactoryCredentials",
        graphql_name="testAzureDataFactoryCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        AzureDataFactoryConnectionDetails,
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "temp_credentials_key",
                    sgqlc.types.Arg(String, graphql_name="tempCredentialsKey", default=None),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Test Azure Data Factory credentials

    Arguments:

    * `connection_details` (`AzureDataFactoryConnectionDetails`):
      Connection parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `temp_credentials_key` (`String`): Optionally provide a
      credentials key to use instead of a credentials object.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_self_hosted_credentials_v2 = sgqlc.types.Field(
        "TestSelfHostedCredentialsV2",
        graphql_name="testSelfHostedCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SelfHostedCredentialsConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Test self-hosted credentials V2

    Arguments:

    * `connection_details`
      (`SelfHostedCredentialsConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    test_dbt_cloud_credentials_v2 = sgqlc.types.Field(
        "TestDbtCloudCredentialsV2",
        graphql_name="testDbtCloudCredentialsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_details",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DbtCloudConnectionDetails),
                        graphql_name="connectionDetails",
                        default=None,
                    ),
                ),
                (
                    "connection_options",
                    sgqlc.types.Arg(
                        ConnectionTestOptions, graphql_name="connectionOptions", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Test dbt Cloud credentials

    Arguments:

    * `connection_details` (`DbtCloudConnectionDetails!`): Connection
      parameters.
    * `connection_options` (`ConnectionTestOptions`): Common options
      for integration tests.
    * `validation_name` (`String!`): Name of the validation test that
      should be run.
    """

    upload_airflow_dag_result = sgqlc.types.Field(
        "UploadAirflowDagResult",
        graphql_name="uploadAirflowDagResult",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dag_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dagId", default=None
                    ),
                ),
                (
                    "end_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endDate", default=None
                    ),
                ),
                (
                    "env",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AirflowEnvInput), graphql_name="env", default=None
                    ),
                ),
                (
                    "execution_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="executionDate", default=None
                    ),
                ),
                (
                    "payload",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GenericScalar), graphql_name="payload", default=None
                    ),
                ),
                ("reason", sgqlc.types.Arg(String, graphql_name="reason", default=None)),
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
                (
                    "run_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="runId", default=None
                    ),
                ),
                (
                    "start_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startDate", default=None
                    ),
                ),
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="state", default=None
                    ),
                ),
                (
                    "success",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="success", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="tags", default=None),
                ),
            )
        ),
    )
    """Upload Airflow DAG run result

    Arguments:

    * `dag_id` (`String!`): DAG identifier
    * `end_date` (`DateTime!`): 'end_date' as returned by Airflow
    * `env` (`AirflowEnvInput!`): Airflow environment information
    * `execution_date` (`DateTime!`): 'execution_date' as returned by
      Airflow
    * `payload` (`GenericScalar!`): Payload for the result, a JSON
      object containing all data gathered form Airflow on the
      callbacks.
    * `reason` (`String`): 'reason' field from Airflow Run
    * `resource_name` (`String`): ETL container name used to
      disambiguate if there are multiple Airflow connections in the
      account. If there's not a single active Airflow connection in
      the given ETL container an error will be thrown. If no
      resource_name is specified then it's expected to be a single
      active Airflow connection on the account.
    * `run_id` (`String!`): DAG Run Identifier
    * `start_date` (`DateTime!`): 'start_date' as returned by Airflow
    * `state` (`String!`): Airflow state, for example success, failed,
      up_for_retry, etc.
    * `success` (`Boolean!`): Flag indicating if the result was
      successful or not
    * `tags` (`[String]`): List of tags associated with the DAG run
    """

    upload_airflow_task_result = sgqlc.types.Field(
        "UploadAirflowTaskResult",
        graphql_name="uploadAirflowTaskResult",
        args=sgqlc.types.ArgDict(
            (
                (
                    "attempt_number",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="attemptNumber", default=None
                    ),
                ),
                (
                    "dag_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dagId", default=None
                    ),
                ),
                ("duration", sgqlc.types.Arg(Float, graphql_name="duration", default=None)),
                (
                    "end_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endDate", default=None
                    ),
                ),
                (
                    "env",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AirflowEnvInput), graphql_name="env", default=None
                    ),
                ),
                (
                    "exception_message",
                    sgqlc.types.Arg(String, graphql_name="exceptionMessage", default=None),
                ),
                (
                    "execution_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="executionDate", default=None
                    ),
                ),
                ("log_url", sgqlc.types.Arg(String, graphql_name="logUrl", default=None)),
                (
                    "next_retry_date",
                    sgqlc.types.Arg(DateTime, graphql_name="nextRetryDate", default=None),
                ),
                (
                    "payload",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GenericScalar), graphql_name="payload", default=None
                    ),
                ),
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
                (
                    "run_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="runId", default=None
                    ),
                ),
                (
                    "start_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startDate", default=None
                    ),
                ),
                (
                    "state",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="state", default=None
                    ),
                ),
                (
                    "success",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="success", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="tags", default=None),
                ),
                (
                    "task_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="taskId", default=None
                    ),
                ),
            )
        ),
    )
    """Upload Airflow Task run result

    Arguments:

    * `attempt_number` (`Int!`): Attempt number for this Task Run, 1
      for the first attempt.
    * `dag_id` (`String!`): DAG identifier
    * `duration` (`Float`): Task Run duration in seconds
    * `end_date` (`DateTime!`): 'end_date' as returned by Airflow
    * `env` (`AirflowEnvInput!`): Airflow environment information
    * `exception_message` (`String`): Exception message obtained from
      Airflow 'exception' attribute
    * `execution_date` (`DateTime!`): 'execution_date' as returned by
      Airflow
    * `log_url` (`String`): URL to access the log for this Task Run
    * `next_retry_date` (`DateTime`): Datetime for the next retry as
      returned by Airflow
    * `payload` (`GenericScalar!`): Payload for the result, a JSON
      object containing all data gathered form Airflow on the
      callbacks.
    * `resource_name` (`String`): ETL container name used to
      disambiguate if there are multiple Airflow connections in the
      account. If there's not a single active Airflow connection in
      the given ETL container an error will be thrown. If no
      resource_name is specified then it's expected to be a single
      active Airflow connection on the account.
    * `run_id` (`String!`): DAG Run Identifier
    * `start_date` (`DateTime!`): 'start_date' as returned by Airflow
    * `state` (`String!`): Airflow state, for example success, failed,
      up_for_retry, etc.
    * `success` (`Boolean!`): Flag indicating if the result was
      successful or not
    * `tags` (`[String]`): List of tags associated with the DAG run
    * `task_id` (`String!`): Airflow Task ID
    """

    upload_airflow_sla_misses = sgqlc.types.Field(
        "UploadAirflowSlaMisses",
        graphql_name="uploadAirflowSlaMisses",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dag_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dagId", default=None
                    ),
                ),
                (
                    "env",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AirflowEnvInput), graphql_name="env", default=None
                    ),
                ),
                (
                    "payload",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GenericScalar), graphql_name="payload", default=None
                    ),
                ),
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
            )
        ),
    )
    """Upload Airflow SLA misses

    Arguments:

    * `dag_id` (`String!`): DAG identifier
    * `env` (`AirflowEnvInput!`): Airflow environment information
    * `payload` (`GenericScalar!`): Payload for the result, a JSON
      object containing all data gathered form Airflow on the
      callbacks.
    * `resource_name` (`String`): ETL container name used to
      disambiguate if there are multiple Airflow connections in the
      account. If there's not a single active Airflow connection in
      the given ETL container an error will be thrown. If no
      resource_name is specified then it's expected to be a single
      active Airflow connection on the account.
    """

    merge_alerts = sgqlc.types.Field(
        MergeAlerts,
        graphql_name="mergeAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "from_alert_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="fromAlertIds",
                        default=None,
                    ),
                ),
                (
                    "to_alert",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MergeAlertsInput), graphql_name="toAlert", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Merge specified alerts into another alert

    Arguments:

    * `from_alert_ids` (`[UUID!]!`): UUID of the alert to merge from
    * `to_alert` (`MergeAlertsInput!`): Merge alerts into specified
      alert
    """

    request_alert_access = sgqlc.types.Field(
        AlertAccessRequestOutput,
        graphql_name="requestAlertAccess",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Request access to view an alert

    Arguments:

    * `alert_id` (`UUID!`): UUID of the alert to request access for
    """

    create_or_update_collibra_integration = sgqlc.types.Field(
        CreateOrUpdateCollibraIntegration,
        graphql_name="createOrUpdateCollibraIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "automatic_sync_disabled",
                    sgqlc.types.Arg(Boolean, graphql_name="automaticSyncDisabled", default=None),
                ),
                ("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),
                (
                    "integration_name",
                    sgqlc.types.Arg(String, graphql_name="integrationName", default=None),
                ),
                (
                    "integration_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="integrationUuid", default=None),
                ),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                ("server_url", sgqlc.types.Arg(String, graphql_name="serverUrl", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "warehouse_domain_mapping",
                    sgqlc.types.Arg(
                        JSONString, graphql_name="warehouseDomainMapping", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Create or update Collibra integration

    Arguments:

    * `automatic_sync_disabled` (`Boolean`): ('If incremental sync and
      full sync are disabled for monitors in this account',)
    * `domain_uuid` (`UUID`): Domain uuid in Collibra where monitors
      will be syncronized. Can only be set once during creation
    * `integration_name` (`String`): Short text to describe the
      integration
    * `integration_uuid` (`UUID`): The integration to update
    * `password` (`String`): ('The Collibra service account password
      for authentication; if not provided, previous value will be
      used',)
    * `server_url` (`String`): The url for your Collibra instance
    * `username` (`String`): ('The Collibra service account username
      for authentication; if not provided, previous value will be
      used',)
    * `warehouse_domain_mapping` (`JSONString`): Custom warehouse
      domain mapping defines which Collibra domains contain warehouse
      tables. MC warehouse UUID is the key and the Collibra domain
      UUID is the value
    """

    delete_collibra_integration = sgqlc.types.Field(
        DeleteCollibraIntegration,
        graphql_name="deleteCollibraIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Delete Collibra integration

    Arguments:

    * `integration_uuid` (`UUID!`): The integration to update
    """

    sync_monitors_to_collibra = sgqlc.types.Field(
        "SyncMonitorsToCollibra",
        graphql_name="syncMonitorsToCollibra",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Sync MC monitors to Collibra

    Arguments:

    * `monitor_uuids` (`[UUID]!`): UUIDs of monitors to sync to
      Collibra.
    """

    create_or_update_alation_integration = sgqlc.types.Field(
        CreateOrUpdateAlationIntegration,
        graphql_name="createOrUpdateAlationIntegration",
        args=sgqlc.types.ArgDict(
            (
                ("dc_proxy", sgqlc.types.Arg(Boolean, graphql_name="dcProxy", default=False)),
                (
                    "disable_ssl_verification",
                    sgqlc.types.Arg(Boolean, graphql_name="disableSslVerification", default=False),
                ),
                (
                    "integration_name",
                    sgqlc.types.Arg(String, graphql_name="integrationName", default=None),
                ),
                (
                    "integration_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="integrationUuid", default=None),
                ),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                (
                    "refresh_token",
                    sgqlc.types.Arg(String, graphql_name="refreshToken", default=None),
                ),
                (
                    "server_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverUrl", default=None
                    ),
                ),
                ("user_id", sgqlc.types.Arg(Int, graphql_name="userId", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "warehouse_datasource_mapping",
                    sgqlc.types.Arg(
                        JSONString, graphql_name="warehouseDatasourceMapping", default=None
                    ),
                ),
            )
        ),
    )
    """Create or update Alation integration

    Arguments:

    * `dc_proxy` (`Boolean`): Whether to proxy requests to the Alation
      instance via the data collector (default: `false`)
    * `disable_ssl_verification` (`Boolean`): Whether to disable SSL
      when proxying requests via the data collector (default: `false`)
    * `integration_name` (`String`): Short text to describe the
      integration
    * `integration_uuid` (`UUID`): The integration to update
    * `password` (`String`): ('The Alation service account password
      for authentication; if not provided, previous value will be
      used',)
    * `refresh_token` (`String`): An Alation service account refresh
      token; if not provided, previous value will be used. Can be
      provided instead of username/password.
    * `server_url` (`String!`): The url for your Alation instance
    * `user_id` (`Int`): ('An Alation service account user ID token;
      if not provided, previous value will be used. Must be provided
      when using a refresh token instead of username/password.',)
    * `username` (`String`): ('The Alation service account username
      for authentication; if not provided, previous value will be
      used',)
    * `warehouse_datasource_mapping` (`JSONString`): Key-value pairs
      consisting of MC warehouse UUID (key) to Alation data source ID
      (value).
    """

    delete_alation_integration = sgqlc.types.Field(
        DeleteAlationIntegration,
        graphql_name="deleteAlationIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Delete Alation integration

    Arguments:

    * `integration_uuid` (`UUID!`): The integration ID
    """

    create_or_update_alation_table_flag = sgqlc.types.Field(
        CreateOrUpdateAlationTableFlag,
        graphql_name="createOrUpdateAlationTableFlag",
        args=sgqlc.types.ArgDict(
            (
                (
                    "flag_reason",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="flagReason", default=None
                    ),
                ),
                (
                    "flag_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TableFlagType), graphql_name="flagType", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Create or update Alation flag on a table. The flag could be a
    warning or a deprecation.

    Arguments:

    * `flag_reason` (`String!`): This may be a reason or a description
      of the flag.Should only be set for DEPRECATION and WARNING.
    * `flag_type` (`TableFlagType!`): The type of the flag
    * `mcon` (`String!`): The MCON of the table
    """

    set_etl_job_generates_incidents = sgqlc.types.Field(
        "SetEtlJobGeneratesIncidents",
        graphql_name="setEtlJobGeneratesIncidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generates_incidents",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean),
                        graphql_name="generatesIncidents",
                        default=None,
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Configures if incidents should be generated or not when a given
    ETL Job (like an Airflow DAG) fails

    Arguments:

    * `generates_incidents` (`Boolean!`): should generate incidents
    * `mcon` (`String!`): job mcon
    """

    set_etl_job_generates_alerts = sgqlc.types.Field(
        "SetEtlJobGeneratesAlerts",
        graphql_name="setEtlJobGeneratesAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generates_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Configures if alerts should be generated or not when a given ETL
    Job (like an Airflow DAG) fails

    Arguments:

    * `generates_alerts` (`Boolean!`): should generate alerts
    * `mcon` (`String!`): job mcon
    """

    bulk_set_etl_job_generates_alerts = sgqlc.types.Field(
        BulkSetEtlJobGeneratesAlerts,
        graphql_name="bulkSetEtlJobGeneratesAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generates_alerts",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Set whether a set of ETL jobs generates alerts or
    not

    Arguments:

    * `generates_alerts` (`Boolean!`): should generate alerts
    * `mcons` (`[String]!`): MCONs of jobs to set generate alerts for
    """

    configure_ai_agent_prompt = sgqlc.types.Field(
        ConfigureAiAgentPrompt,
        graphql_name="configureAiAgentPrompt",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AiAgentType), graphql_name="agentType", default=None
                    ),
                ),
                (
                    "context_prompt",
                    sgqlc.types.Arg(String, graphql_name="contextPrompt", default=None),
                ),
            )
        ),
    )
    """(experimental) Configure the context prompt for an AI agent

    Arguments:

    * `agent_type` (`AiAgentType!`): Type of AI agent to configure
    * `context_prompt` (`String`): Custom context prompt for the
      agent. Pass null to clear.
    """

    create_account_secret = sgqlc.types.Field(
        CreateAccountSecret,
        graphql_name="createAccountSecret",
        args=sgqlc.types.ArgDict(
            (
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("expires_at", sgqlc.types.Arg(DateTime, graphql_name="expiresAt", default=None)),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                (
                    "scope",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="scope", default=None
                    ),
                ),
                (
                    "value",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="value", default=None
                    ),
                ),
            )
        ),
    )
    """Create an account secret

    Arguments:

    * `description` (`String`): The secret description
    * `expires_at` (`DateTime`): When does the secret expire. Null if
      it doesn't expire.
    * `name` (`String!`): The secret name
    * `scope` (`String!`): The secret scope
    * `value` (`String!`): The secret value.
    """

    update_account_secret = sgqlc.types.Field(
        "UpdateAccountSecret",
        graphql_name="updateAccountSecret",
        args=sgqlc.types.ArgDict(
            (
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("expires_at", sgqlc.types.Arg(DateTime, graphql_name="expiresAt", default=None)),
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                (
                    "scope",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="scope", default=None
                    ),
                ),
                ("value", sgqlc.types.Arg(String, graphql_name="value", default=None)),
            )
        ),
    )
    """Update an account secret

    Arguments:

    * `description` (`String`): The secret description
    * `expires_at` (`DateTime`): When does the secret expire. Null if
      it doesn't expire.
    * `name` (`String!`): The secret name
    * `scope` (`String!`): The secret scope
    * `value` (`String`): The secret value. If not provided, the value
      will not be changed.
    """

    delete_account_secret = sgqlc.types.Field(
        DeleteAccountSecret,
        graphql_name="deleteAccountSecret",
        args=sgqlc.types.ArgDict(
            (
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
            )
        ),
    )
    """Delete an account secret

    Arguments:

    * `name` (`String!`): The secret name
    """


class NameRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name",)
    name = sgqlc.types.Field(String, graphql_name="name")


class NestedHighlightSnippets(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("offset", "inner_hit_snippets")
    offset = sgqlc.types.Field(Int, graphql_name="offset")
    """Offset into nested field"""

    inner_hit_snippets = sgqlc.types.Field(
        sgqlc.types.list_of(HighlightSnippets), graphql_name="innerHitSnippets"
    )
    """Highlighted snippet of inner hit"""


class NetworkDetails(sgqlc.types.Type):
    """Network information"""

    __schema__ = schema
    __field_names__ = (
        "collection_public_ip_addresses",
        "saas_public_ip_addresses",
        "external_webhook_public_ip_addresses",
        "data_platform_public_ip_addresses",
    )
    collection_public_ip_addresses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)),
        graphql_name="collectionPublicIpAddresses",
    )
    """List of public IP addresses used by the collection platform"""

    saas_public_ip_addresses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="saasPublicIpAddresses"
    )
    """List of public IP addresses used by the SaaS platform"""

    external_webhook_public_ip_addresses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)),
        graphql_name="externalWebhookPublicIpAddresses",
    )
    """List of public IP addresses used by the webhooks"""

    data_platform_public_ip_addresses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)),
        graphql_name="dataPlatformPublicIpAddresses",
    )
    """List of public IP addresses used by the data platform"""


class NextPageInfo(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("has_next_page", "end_cursor")
    has_next_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasNextPage")
    """When paginating forwards, are there more items?"""

    end_cursor = sgqlc.types.Field(String, graphql_name="endCursor")
    """If there is next page, use this cursor to continue"""


class NodeEdgeCSVStrings(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes_str", "edges_str")
    nodes_str = sgqlc.types.Field(String, graphql_name="nodesStr")
    """String containing CSV of nodes"""

    edges_str = sgqlc.types.Field(String, graphql_name="edgesStr")
    """String containing CSV of edges"""


class NodeEdgeGraph(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes", "edges")
    nodes = sgqlc.types.Field(sgqlc.types.list_of(LineageGraphNode), graphql_name="nodes")
    """Lineage nodes"""

    edges = sgqlc.types.Field(sgqlc.types.list_of(GraphEdge), graphql_name="edges")
    """Lineage edges"""


class NodeEdgeStrings(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("nodes_str", "edges_str")
    nodes_str = sgqlc.types.Field(String, graphql_name="nodesStr")
    """String containing JSON of nodes"""

    edges_str = sgqlc.types.Field(String, graphql_name="edgesStr")
    """String containing JSON of edges"""


class NodeProperties(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "workbook_id",
        "friendly_name",
        "content_url",
        "owner_id",
        "project_id",
        "project_name",
        "created",
        "updated",
        "total_views",
        "workbook_creators",
        "view_id",
        "category",
        "mcon",
        "name",
        "display_name",
        "table_id",
        "data_set",
        "node_id",
        "resource",
        "sampling",
    )
    workbook_id = sgqlc.types.Field(String, graphql_name="workbookId")

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")

    content_url = sgqlc.types.Field(String, graphql_name="contentUrl")

    owner_id = sgqlc.types.Field(String, graphql_name="ownerId")

    project_id = sgqlc.types.Field(String, graphql_name="projectId")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    created = sgqlc.types.Field(DateTime, graphql_name="created")

    updated = sgqlc.types.Field(DateTime, graphql_name="updated")

    total_views = sgqlc.types.Field(Int, graphql_name="totalViews")

    workbook_creators = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="workbookCreators"
    )

    view_id = sgqlc.types.Field(String, graphql_name="viewId")

    category = sgqlc.types.Field(String, graphql_name="category")
    """Node type"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Monte Carlo object name"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Object name (table name, report name, etc)"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Friendly display name"""

    table_id = sgqlc.types.Field(String, graphql_name="tableId")

    data_set = sgqlc.types.Field(String, graphql_name="dataSet")

    node_id = sgqlc.types.Field(String, graphql_name="nodeId")
    """Lineage node id, to be deprecated in favor of MCONs"""

    resource = sgqlc.types.Field(String, graphql_name="resource")
    """Resource containing this object (warehouse, Tableau account, etc)"""

    sampling = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="sampling")
    """A subset of the nodes that were collapsed into a node, only
    present on nodes of type collapsed-etl or collapsed-ext
    """


class NotMonitoredReason(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "reason", "rule")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON of the asset"""

    reason = sgqlc.types.Field(IsNotMonitoredReason, graphql_name="reason")
    """Reason why the asset is not monitored"""

    rule = sgqlc.types.Field(MonitoredTableRuleObject, graphql_name="rule")
    """The rule that caused the asset to be not monitored"""


class NotificationAudience(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "account_uuid",
        "label",
        "created_by",
        "default_failure_audience",
        "routing_rules",
        "notification_settings",
        "routing_rules_count",
        "custom_monitors",
        "custom_monitors_count",
        "notification_services",
        "notification_settings_count",
        "incident_count_history",
        "incident_count",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique identifier of a monitor label"""

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")
    """Account identifier"""

    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")
    """Monitor label name"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Monitor label creator"""

    default_failure_audience = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="defaultFailureAudience"
    )
    """When creating a new monitor, this audience should be included, by
    default, in the monitor's list of failure_audiences
    """

    routing_rules = sgqlc.types.Field(
        "NotificationRoutingRuleConnection",
        graphql_name="routingRules",
        args=sgqlc.types.ArgDict(
            (
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default="uuid")),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Routing rules for this audience

    Arguments:

    * `order_by` (`String`): Specify a sorting order (default:
      `"uuid"`)
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    notification_settings = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("NotificationSetting")),
        graphql_name="notificationSettings",
    )
    """Notification settings for this audience"""

    routing_rules_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="routingRulesCount"
    )
    """Number of routing rules for this audience"""

    custom_monitors = sgqlc.types.Field(
        AudienceMonitorConnection,
        graphql_name="customMonitors",
        args=sgqlc.types.ArgDict(
            (
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default="uuid")),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Custom monitors for this audience

    Arguments:

    * `order_by` (`String`): Specify a sorting order (default:
      `"uuid"`)
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    custom_monitors_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="customMonitorsCount"
    )
    """Number of custom monitors for this audience"""

    notification_services = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="notificationServices"
    )
    """Notification services for this audience"""

    notification_settings_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="notificationSettingsCount"
    )
    """Number of notification settings for this audience"""

    incident_count_history = sgqlc.types.Field(
        sgqlc.types.list_of("NotificationIncidentDailyCount"), graphql_name="incidentCountHistory"
    )
    """Number of incidents per day for the past 30 days"""

    incident_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="incidentCount")
    """The number of distinct notified incidents in the past 30 days"""


class NotificationDailyCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("day", "notification_count")
    day = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="day")
    """The date for the notification count"""

    notification_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="notificationCount"
    )
    """The notification count"""


class NotificationIncidentDailyCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("day", "incident_count")
    day = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="day")
    """The date for the notification count"""

    incident_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="incidentCount")
    """The number of distinct notified incidents"""


class NotificationRecordCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "account_uuid",
        "audience_uuid",
        "incident_notifications",
        "digest_notifications",
    )
    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")
    """Account UUID"""

    audience_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="audienceUuid")
    """Audience UUID"""

    incident_notifications = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="incidentNotifications"
    )
    """Incident notification count over the last 30 days"""

    digest_notifications = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="digestNotifications"
    )
    """Digest notification count over the last 30 days"""


class NotificationRoutingRule(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "table_rules",
        "tag_rules",
        "sql_rules",
        "table_stats_rules",
        "domain_rules",
        "table_id_rules",
        "asset_rules",
        "anomaly_types",
        "incident_sub_types",
        "custom_message",
        "digest_settings",
        "audience",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "incident_count_history",
        "incident_count",
        "alert_sub_types",
        "asset_display_names",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """The route rule id"""

    table_rules = sgqlc.types.Field(String, graphql_name="tableRules")
    """Table/dataset based rules (regex)"""

    tag_rules = sgqlc.types.Field(JSONString, graphql_name="tagRules")
    """Key and key/value based rules"""

    sql_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="sqlRules"
    )
    """Custom sql rules"""

    table_stats_rules = sgqlc.types.Field(JSONString, graphql_name="tableStatsRules")
    """Rules based on table stats (importance_score, is_important)."""

    domain_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainRules"
    )
    """List of domain UUIDs to match event objects against."""

    table_id_rules = sgqlc.types.Field(JSONString, graphql_name="tableIdRules")
    """Project/dataset/table based rules"""

    asset_rules = sgqlc.types.Field(JSONString, graphql_name="assetRules")
    """Asset based rules"""

    anomaly_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="anomalyTypes"
    )
    """List of supported incident types to send notifications for"""

    incident_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="incidentSubTypes"
    )
    """All the incident sub-types this notification settings will alert
    on.
    """

    custom_message = sgqlc.types.Field(String, graphql_name="customMessage")
    """Custom text to be included with the notification"""

    digest_settings = sgqlc.types.Field(
        AccountNotificationDigestSettings, graphql_name="digestSettings"
    )
    """Digest notification settings for events matching the rule"""

    audience = sgqlc.types.Field(NotificationAudience, graphql_name="audience")

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator of the routing rule"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Routing rule last updated by"""

    incident_count_history = sgqlc.types.Field(
        sgqlc.types.list_of(NotificationIncidentDailyCount), graphql_name="incidentCountHistory"
    )
    """Number of incidents per day for the past 30 days"""

    incident_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="incidentCount")
    """The number of distinct notified incidents in the past 30 days"""

    alert_sub_types = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="alertSubTypes")
    """All the alert sub-types this notification settings will alert on."""

    asset_display_names = sgqlc.types.Field(JSONString, graphql_name="assetDisplayNames")
    """The display names of the assets used in rules for this routing
    rule (in JSON)
    """


class NotificationRoutingRuleConnection(sgqlc.types.relay.Connection):
    """Notification routing rules response"""

    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("NotificationRoutingRuleEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class NotificationRoutingRuleEdge(sgqlc.types.Type):
    """A Relay edge containing a `NotificationRoutingRule` and its
    cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(NotificationRoutingRule, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class NotificationSetting(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "created_by",
        "created_time",
        "last_updated_by",
        "last_update_time",
        "name",
        "is_template_managed",
        "namespace",
        "type",
        "recipients",
        "extra",
        "notification_enabled",
        "audience",
        "integration_uuid",
        "recipients_display_names",
        "custom_display_names",
        "incident_count_history",
        "incident_count",
        "integration_id",
        "team_id",
        "channel_url",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Effective ID for notification settings"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator of the notification"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the notification was first created"""

    last_updated_by = sgqlc.types.Field("User", graphql_name="lastUpdatedBy")
    """User who last updated this notification"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the notification was last updated"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Resource name for notifications created through notifications-as-
    code
    """

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )
    """Is this monitor managed by a configuration template
    (notifications-as-code)?
    """

    namespace = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="namespace")
    """Namespace of notification, used for notifications-as-code"""

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AccountNotificationSettingsModelType), graphql_name="type"
    )
    """Type of notification integration (e.g. slack)"""

    recipients = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="recipients"
    )
    """Destinations to send notifications to"""

    extra = sgqlc.types.Field(JSONString, graphql_name="extra")
    """Any additional information for various notification integrations"""

    notification_enabled = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="notificationEnabled"
    )
    """When enabled notifications for this setting are sent."""

    audience = sgqlc.types.Field(NotificationAudience, graphql_name="audience")

    integration_uuid = sgqlc.types.Field(UUID, graphql_name="integrationUuid")
    """UUID for a recipient integration"""

    recipients_display_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="recipientsDisplayNames"
    )

    custom_display_names = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="customDisplayNames"
    )

    incident_count_history = sgqlc.types.Field(
        sgqlc.types.list_of(NotificationIncidentDailyCount), graphql_name="incidentCountHistory"
    )
    """Number of incidents per day for the past 30 days"""

    incident_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="incidentCount")
    """The number of distinct notified incidents in the past 30 days"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Integration ID for the recipient"""

    team_id = sgqlc.types.Field(String, graphql_name="teamId")
    """Slack team/workspace ID (only for Slack notifications)"""

    channel_url = sgqlc.types.Field(String, graphql_name="channelUrl")
    """URL of the channel if this is a channel-based notification.
    Currently only Slack and MS Teams is supported.
    """


class NumericAnomalyCorrelation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field", "metric", "value", "historical_value", "correlations", "outliers")
    field = sgqlc.types.Field(String, graphql_name="field")
    """The name of the field we ran the correlation for"""

    metric = sgqlc.types.Field(String, graphql_name="metric")
    """The metric for the field we ran the correlation for"""

    value = sgqlc.types.Field(Float, graphql_name="value")
    """The breach value"""

    historical_value = sgqlc.types.Field(Float, graphql_name="historicalValue")
    """The historical value"""

    correlations = sgqlc.types.Field(
        sgqlc.types.list_of(FieldValueCorrelation), graphql_name="correlations"
    )
    """The field/value pairs correlation with the breach"""

    outliers = sgqlc.types.Field("NumericAnomalyOutliers", graphql_name="outliers")
    """A list of rows that caused the breach"""


class NumericAnomalyOutliers(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("columns", "rows")
    columns = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="columns")

    rows = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.list_of(String)), graphql_name="rows")


class NumericCorrelationRcaResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("numeric_anomalies",)
    numeric_anomalies = sgqlc.types.Field(
        sgqlc.types.list_of(NumericAnomalyCorrelation), graphql_name="numericAnomalies"
    )


class ObjectDocument(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "resource_id",
        "object_id",
        "object_type",
        "display_name",
        "field_metadata",
        "table_metadata",
        "bi_metadata",
        "vector_index_metadata",
        "properties",
    )
    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    resource_id = sgqlc.types.Field(String, graphql_name="resourceId")

    object_id = sgqlc.types.Field(String, graphql_name="objectId")

    object_type = sgqlc.types.Field(String, graphql_name="objectType")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")

    field_metadata = sgqlc.types.Field(FieldMetadata, graphql_name="fieldMetadata")

    table_metadata = sgqlc.types.Field("TableMetadata", graphql_name="tableMetadata")

    bi_metadata = sgqlc.types.Field(BiMetadata, graphql_name="biMetadata")

    vector_index_metadata = sgqlc.types.Field(
        "VectorIndexMetadata", graphql_name="vectorIndexMetadata"
    )

    properties = sgqlc.types.Field(
        sgqlc.types.list_of("ObjectPropertyEntry"), graphql_name="properties"
    )


class ObjectPropertyConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("ObjectPropertyEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class ObjectPropertyEdge(sgqlc.types.Type):
    """A Relay edge containing a `ObjectProperty` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("ObjectProperty", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class ObjectPropertyEntry(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(String, graphql_name="name")

    value = sgqlc.types.Field(String, graphql_name="value")


class OpsgenieIntegrationOutput(sgqlc.types.Type):
    """An Opsgenie integration"""

    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "integration_name",
        "webhook_enabled",
        "webhook_secret_name",
        "webhook_secret_mismatch_detected",
        "integration_id",
        "integration_key",
        "server_url",
        "webhook_url",
        "webhook_secret_defined",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """Short text to describe the integration"""

    webhook_enabled = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="webhookEnabled"
    )
    """Webhook enabled"""

    webhook_secret_name = sgqlc.types.Field(String, graphql_name="webhookSecretName")
    """Name (header) for the Opsgenie secret provided for the webhook"""

    webhook_secret_mismatch_detected = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="webhookSecretMismatchDetected"
    )
    """Indicates a mismatch was detected in the secret of a received
    webhook
    """

    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")

    integration_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="integrationKey")

    server_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="serverUrl")

    webhook_url = sgqlc.types.Field(String, graphql_name="webhookUrl")
    """The webhook URL"""

    webhook_secret_defined = sgqlc.types.Field(Boolean, graphql_name="webhookSecretDefined")
    """If a secret is configured"""


class OpsgenieLinkOutput(sgqlc.types.Type):
    """Opsgenie Incident link details"""

    __schema__ = schema
    __field_names__ = ("alert_id", "tiny_id")
    alert_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="alertId")
    """The Opsgenie Incident's Alert ID"""

    tiny_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tinyId")
    """The Opsgenie Incident's Tiny ID"""


class Override(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dialect", "sql", "negated_sql")
    dialect = sgqlc.types.Field(sgqlc.types.non_null(SqlDialect), graphql_name="dialect")

    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")

    negated_sql = sgqlc.types.Field(String, graphql_name="negatedSql")


class OwnerRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "username", "email")
    name = sgqlc.types.Field(String, graphql_name="name")

    username = sgqlc.types.Field(String, graphql_name="username")

    email = sgqlc.types.Field(String, graphql_name="email")


class PageInfo(sgqlc.types.Type):
    """The Relay compliant `PageInfo` type, containing data necessary to
    paginate this connection.
    """

    __schema__ = schema
    __field_names__ = ("has_next_page", "has_previous_page", "start_cursor", "end_cursor")
    has_next_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasNextPage")
    """When paginating forwards, are there more items?"""

    has_previous_page = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasPreviousPage"
    )
    """When paginating backwards, are there more items?"""

    start_cursor = sgqlc.types.Field(String, graphql_name="startCursor")
    """When paginating backwards, the cursor to continue."""

    end_cursor = sgqlc.types.Field(String, graphql_name="endCursor")
    """When paginating forwards, the cursor to continue."""


class PagerDutyServiceIntegrationOutput(sgqlc.types.Type):
    """A PagerDuty service integration"""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "integration_key",
        "webhook_enabled",
        "webhook_url",
        "webhook_secret_defined",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "webhook_secret_mismatch_detected",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """A short name to identify the integration"""

    integration_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="integrationKey")
    """Integration Key associated with the PagerDuty service to integrate"""

    webhook_enabled = sgqlc.types.Field(Boolean, graphql_name="webhookEnabled")
    """Whether the PagerDuty webhook is enabled"""

    webhook_url = sgqlc.types.Field(String, graphql_name="webhookUrl")
    """The PagerDuty webhook URL. Configure this as the target of your
    PagerDuty Webhook.
    """

    webhook_secret_defined = sgqlc.types.Field(Boolean, graphql_name="webhookSecretDefined")
    """Whether a secret has been configured for validating the signatures
    of webhook payloads sent by PagerDuty
    """

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the integration"""

    webhook_secret_mismatch_detected = sgqlc.types.Field(
        Boolean, graphql_name="webhookSecretMismatchDetected"
    )
    """Indicates whether a mismatch was detected for the PagerDuty secret
    in the received payloads
    """


class PaginateUsersBlastRadius2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("after_key", "data", "total_count")
    after_key = sgqlc.types.Field(String, graphql_name="afterKey")
    """The after key to use for pagination"""

    data = sgqlc.types.Field(sgqlc.types.list_of("UserBlastRadius2"), graphql_name="data")
    """The user blast radius data"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """The total number of users"""


class ParsedQueryResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("parsed_query",)
    parsed_query = sgqlc.types.Field(String, graphql_name="parsedQuery")
    """Query, based on which the table's created"""


class PartialObjectProperty(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("property_name", "property_value")
    property_name = sgqlc.types.Field(String, graphql_name="propertyName")
    """Name of the attached property"""

    property_value = sgqlc.types.Field(String, graphql_name="propertyValue")
    """Value of the attached property"""


class PauseMonitor(sgqlc.types.Type):
    """Pause a monitor from collecting data.'"""

    __schema__ = schema
    __field_names__ = ("monitor",)
    monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="monitor")
    """The monitor whose pause property has been toggled."""


class PauseMonitorBootstrap(sgqlc.types.Type):
    """Pause the monitor bootstrapping process to stop executing new jobs
    that collect historical data.
    """

    __schema__ = schema
    __field_names__ = ("monitor",)
    monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="monitor")
    """The monitor whose bootstrapping was paused"""


class PauseMonitors(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class PauseRule(sgqlc.types.Type):
    """Pause a rule from collecting data or triggering notifications"""

    __schema__ = schema
    __field_names__ = ("rule",)
    rule = sgqlc.types.Field("CustomRule", graphql_name="rule")
    """The rule whose pause property has been toggled."""


class PauseTableMonitor(sgqlc.types.Type):
    """Pause/unpause a table monitor to enable or suppress notifications"""

    __schema__ = schema
    __field_names__ = ("table_monitor",)
    table_monitor = sgqlc.types.Field("TableMonitor", graphql_name="tableMonitor")


class PiiFilterMetricOutput(sgqlc.types.Type):
    """A container for PII filter metrics per completed job execution
    aggregated by job type, warehouse and PII filter name.
    """

    __schema__ = schema
    __field_names__ = ("filter_name", "job_type", "resource_id", "total_replacements")
    filter_name = sgqlc.types.Field(String, graphql_name="filterName")
    """The unique name for the filter that was run."""

    job_type = sgqlc.types.Field(String, graphql_name="jobType")
    """The type of job the PII filter run was a part of."""

    resource_id = sgqlc.types.Field(UUID, graphql_name="resourceId")
    """The UUID of the resource the PII filtering ran on."""

    total_replacements = sgqlc.types.Field(Int, graphql_name="totalReplacements")
    """Total number of text occurrences replaced by this filter across
    the job runs.
    """


class PiiFilterOutput(sgqlc.types.Type):
    """A container for a regex pattern used to match data for redaction
    of PII information.
    """

    __schema__ = schema
    __field_names__ = ("name", "description", "pattern", "on_by_default", "enabled")
    name = sgqlc.types.Field(String, graphql_name="name")
    """The unique name of the PII filter."""

    description = sgqlc.types.Field(String, graphql_name="description")
    """The explanation of the PII filter's purpose."""

    pattern = sgqlc.types.Field(String, graphql_name="pattern")
    """The regex matching pattern of the PII filter."""

    on_by_default = sgqlc.types.Field(Boolean, graphql_name="onByDefault")
    """Whether this PII filter is on by default globally."""

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Whether this PII filter is enabled for this account."""


class PiiFilteringPreferencesOutput(sgqlc.types.Type):
    """A container describing this account's PII filtering customizations
    and settings.
    """

    __schema__ = schema
    __field_names__ = ("enabled", "fail_mode")
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Whether PII filtering is enabled for this account."""

    fail_mode = sgqlc.types.Field(PiiFilteringFailModeType, graphql_name="failMode")
    """Whether PII filter failures will allow (open) or prevent (close)
    data flow for this account.
    """


class PineconeVectorIndexMetadata(sgqlc.types.Type):
    """Pinecone-specific metadata"""

    __schema__ = schema
    __field_names__ = ("dimensions", "host", "metric", "pod_type", "pods", "replicas", "shards")
    dimensions = sgqlc.types.Field(Int, graphql_name="dimensions")

    host = sgqlc.types.Field(String, graphql_name="host")

    metric = sgqlc.types.Field(String, graphql_name="metric")

    pod_type = sgqlc.types.Field(String, graphql_name="podType")

    pods = sgqlc.types.Field(Int, graphql_name="pods")

    replicas = sgqlc.types.Field(Int, graphql_name="replicas")

    shards = sgqlc.types.Field(Int, graphql_name="shards")


class PipelineData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "pipe_mcon",
        "display_name",
        "importance_score",
        "table_count",
        "monitored_table_count",
        "orphaned_table_count",
    )
    pipe_mcon = sgqlc.types.Field(String, graphql_name="pipeMcon")
    """Pipe unique identifier"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Name of pipeline to be displayed"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """Pipeline importance score"""

    table_count = sgqlc.types.Field(Int, graphql_name="tableCount")
    """Number of tables in the pipeline"""

    monitored_table_count = sgqlc.types.Field(Int, graphql_name="monitoredTableCount")
    """Number of tables monitored in the pipeline"""

    orphaned_table_count = sgqlc.types.Field(Int, graphql_name="orphanedTableCount")
    """Number of tables left orphaned in the pipeline"""


class PipelinesData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_count", "offset", "pipeline_data")
    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of pipelines found"""

    offset = sgqlc.types.Field(Int, graphql_name="offset")
    """Paging offset"""

    pipeline_data = sgqlc.types.Field(
        sgqlc.types.list_of(PipelineData), graphql_name="pipelineData"
    )


class PlatformMigrationStatusResponse(sgqlc.types.Type):
    """DC migration status"""

    __schema__ = schema
    __field_names__ = ("status", "target_dc", "target_node", "output")
    status = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="status")
    """Description of the migration status for the DC"""

    target_dc = sgqlc.types.Field(String, graphql_name="targetDc")
    """UUID of the new DC the input DC was migrated to"""

    target_node = sgqlc.types.Field(String, graphql_name="targetNode")
    """ID of the node the input DC was migrated to"""

    output = sgqlc.types.Field(GenericScalar, graphql_name="output")
    """Additional output from the migration process"""


class PlatformMigrationTestStatusResponse(sgqlc.types.Type):
    """Platform migration test status"""

    __schema__ = schema
    __field_names__ = ("output",)
    output = sgqlc.types.Field(GenericScalar, graphql_name="output")
    """Output from the test migration process"""


class PlatformRegionProperties(sgqlc.types.Type):
    """Region-specific platform properties"""

    __schema__ = schema
    __field_names__ = (
        "gateway_endpoint",
        "gateway_vpce",
        "linker_arn",
        "log_arn",
        "template_launch_url",
    )
    gateway_endpoint = sgqlc.types.Field(String, graphql_name="gatewayEndpoint")
    """Gateway endpoint URL"""

    gateway_vpce = sgqlc.types.Field(String, graphql_name="gatewayVpce")
    """Gateway VPC id"""

    linker_arn = sgqlc.types.Field(String, graphql_name="linkerArn")
    """ARN of SNS topic used to link data collector deployment"""

    log_arn = sgqlc.types.Field(String, graphql_name="logArn")
    """ARN of CloudWatch log destination for cross-account log
    subscriptions
    """

    template_launch_url = sgqlc.types.Field(String, graphql_name="templateLaunchUrl")
    """CloudFormation template launch URL"""


class PlatformServiceAgent(sgqlc.types.Type):
    """Platform service agent information"""

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "endpoint",
        "agent_type",
        "platform",
        "created_on",
        "wrapper",
        "last_updated_on",
        "version",
        "wrapper_version",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the agent"""

    endpoint = sgqlc.types.Field(String, graphql_name="endpoint")
    """Agent endpoint"""

    agent_type = sgqlc.types.Field(AgentTypeEnum, graphql_name="agentType")
    """Agent type"""

    platform = sgqlc.types.Field(PlatformTypeEnum, graphql_name="platform")
    """Agent platform"""

    created_on = sgqlc.types.Field(DateTime, graphql_name="createdOn")
    """Agent creation date"""

    wrapper = sgqlc.types.Field(String, graphql_name="wrapper")
    """Agent wrapper"""

    last_updated_on = sgqlc.types.Field(DateTime, graphql_name="lastUpdatedOn")
    """Agent last update date"""

    version = sgqlc.types.Field(String, graphql_name="version")
    """Agent version"""

    wrapper_version = sgqlc.types.Field(String, graphql_name="wrapperVersion")
    """Agent wrapper version"""


class PlatformServiceConnection(sgqlc.types.relay.Connection):
    """Platform service connection information"""

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "resource_uuid",
        "name",
        "connection_type",
        "subtype",
        "created_on",
        "identifiers",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the connection"""

    resource_uuid = sgqlc.types.Field(UUID, graphql_name="resourceUuid")
    """UUID of the resource containing the connection"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Connection name"""

    connection_type = sgqlc.types.Field(ConnectionTypeEnum, graphql_name="connectionType")
    """Connection type"""

    subtype = sgqlc.types.Field(ConnectionSubtypeEnum, graphql_name="subtype")
    """Connection subtype"""

    created_on = sgqlc.types.Field(DateTime, graphql_name="createdOn")
    """Connection creation date"""

    identifiers = sgqlc.types.Field(GenericScalar, graphql_name="identifiers")
    """Connection identifiers"""


class PlatformServiceDeployment(sgqlc.types.Type):
    """Platform service deployment information"""

    __schema__ = schema
    __field_names__ = ("deployment_type", "platform", "agent")
    deployment_type = sgqlc.types.Field(
        DataCollectorDeploymentTypeExtendedEnum, graphql_name="deploymentType"
    )
    """Deployment type"""

    platform = sgqlc.types.Field("PlatformServicePlatform", graphql_name="platform")
    """Platform information"""

    agent = sgqlc.types.Field(PlatformServiceAgent, graphql_name="agent")
    """Agent information"""


class PlatformServiceObject(sgqlc.types.Type):
    """Platform service information"""

    __schema__ = schema
    __field_names__ = ("uuid", "deployment", "connections", "support_status", "name")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the platform service"""

    deployment = sgqlc.types.Field(PlatformServiceDeployment, graphql_name="deployment")
    """Deployment information"""

    connections = sgqlc.types.Field(
        sgqlc.types.list_of(PlatformServiceConnection), graphql_name="connections"
    )
    """List of connections"""

    support_status = sgqlc.types.Field("PlatformServiceSupportStatus", graphql_name="supportStatus")
    """Detailed information about support for the features requested
    using supports* parameters
    """

    name = sgqlc.types.Field(String, graphql_name="name")
    """Name of the platform service"""


class PlatformServicePlatform(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "resources",
        "ip_addresses",
        "data_store_encryption",
        "created_on",
        "last_updated_on",
        "assigned_on",
        "code_version",
        "template_version",
        "execution_roles",
    )
    resources = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="resources")
    """Platform resources"""

    ip_addresses = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="ipAddresses")
    """Platform IP addresses"""

    data_store_encryption = sgqlc.types.Field(
        StorageEncryptionType, graphql_name="dataStoreEncryption"
    )
    """Type of storage encryption for the data store"""

    created_on = sgqlc.types.Field(DateTime, graphql_name="createdOn")
    """Service creation date"""

    last_updated_on = sgqlc.types.Field(DateTime, graphql_name="lastUpdatedOn")
    """Service last update date"""

    assigned_on = sgqlc.types.Field(DateTime, graphql_name="assignedOn")
    """Service last update date"""

    code_version = sgqlc.types.Field(String, graphql_name="codeVersion")
    """Service code version"""

    template_version = sgqlc.types.Field(String, graphql_name="templateVersion")
    """Service template version"""

    execution_roles = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="executionRoles")
    """Service execution roles"""


class PlatformServiceSupportStatus(sgqlc.types.Type):
    """Information about the support for required features (connection
    type, agent platform, etc.).
    """

    __schema__ = schema
    __field_names__ = ("code", "details")
    code = sgqlc.types.Field(PlatformServiceSupportCode, graphql_name="code")
    """Support code, SUPPORTED indicates the required features are all
    supported.
    """

    details = sgqlc.types.Field(GenericScalar, graphql_name="details")
    """Additional details related to the support status code, such as
    required minimum version, etc.
    """


class PowerBIDashboardTileRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tile_id", "tile_title", "tile_sub_title", "report_name", "report_id")
    tile_id = sgqlc.types.Field(String, graphql_name="tileId")

    tile_title = sgqlc.types.Field(String, graphql_name="tileTitle")

    tile_sub_title = sgqlc.types.Field(String, graphql_name="tileSubTitle")

    report_name = sgqlc.types.Field(String, graphql_name="reportName")

    report_id = sgqlc.types.Field(String, graphql_name="reportId")


class PowerBIWorkSpaceRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "id", "type", "state", "description")
    name = sgqlc.types.Field(String, graphql_name="name")

    id = sgqlc.types.Field(String, graphql_name="id")

    type = sgqlc.types.Field(String, graphql_name="type")

    state = sgqlc.types.Field(String, graphql_name="state")

    description = sgqlc.types.Field(String, graphql_name="description")


class Predicate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "description",
        "sql",
        "arity",
        "overrides",
        "supported_types",
        "required_type",
        "allow_many_left",
        "allow_many_right",
        "used_in_literal_right",
        "used_in_literal_left",
        "allow_negation",
        "negated_description",
        "negated_sql",
        "category",
        "supported_connections",
        "mc_sql_supported",
        "python_eval",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")

    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")

    arity = sgqlc.types.Field(sgqlc.types.non_null(PredicateArity), graphql_name="arity")

    overrides = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Override))),
        graphql_name="overrides",
    )

    supported_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FieldType))),
        graphql_name="supportedTypes",
    )

    required_type = sgqlc.types.Field(
        sgqlc.types.non_null(PredicateRequiredType), graphql_name="requiredType"
    )

    allow_many_left = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowManyLeft")

    allow_many_right = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="allowManyRight"
    )

    used_in_literal_right = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usedInLiteralRight"
    )

    used_in_literal_left = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usedInLiteralLeft"
    )

    allow_negation = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowNegation")

    negated_description = sgqlc.types.Field(String, graphql_name="negatedDescription")

    negated_sql = sgqlc.types.Field(String, graphql_name="negatedSql")

    category = sgqlc.types.Field(String, graphql_name="category")

    supported_connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="supportedConnections",
    )

    mc_sql_supported = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="mcSqlSupported"
    )

    python_eval = sgqlc.types.Field(String, graphql_name="pythonEval")


class PrimaryRcaData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("event_uuid", "rca_uuid")
    event_uuid = sgqlc.types.Field(UUID, graphql_name="eventUuid")

    rca_uuid = sgqlc.types.Field(UUID, graphql_name="rcaUuid")


class PrivateLinkDetails(sgqlc.types.Type):
    """Private Link information"""

    __schema__ = schema
    __field_names__ = ("aws",)
    aws = sgqlc.types.Field(sgqlc.types.non_null(AwsPrivateLinkDetails), graphql_name="aws")
    """AWS Private Link information"""


class ProjectAllowType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("project_name", "datasets")
    project_name = sgqlc.types.Field(String, graphql_name="projectName")
    """Project name"""

    datasets = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="datasets")
    """List of allowed datasets in project"""


class ProjectConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("ProjectEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class ProjectEdge(sgqlc.types.Type):
    """A Relay edge containing a `Project` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("Project", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class ProjectEntity(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("project_id", "friendly_name")
    project_id = sgqlc.types.Field(String, graphql_name="projectId")
    """Project ID"""

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")
    """Friendly name of the project"""


class PropertyNameValue(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(String, graphql_name="name")

    value = sgqlc.types.Field(String, graphql_name="value")


class PropertyNameValues(sgqlc.types.Type):
    """All unique object property names/values"""

    __schema__ = schema
    __field_names__ = ("property_name_values", "has_next_page")
    property_name_values = sgqlc.types.Field(
        sgqlc.types.list_of(PropertyNameValue), graphql_name="propertyNameValues"
    )
    """List of unique object property name/value pairs"""

    has_next_page = sgqlc.types.Field(Boolean, graphql_name="hasNextPage")
    """there are more pages to be retrieved"""


class PropertyNames(sgqlc.types.Type):
    """All unique object property names"""

    __schema__ = schema
    __field_names__ = ("property_names",)
    property_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="propertyNames")
    """List of object property names"""


class PropertyValues(sgqlc.types.Type):
    """All unique object property names"""

    __schema__ = schema
    __field_names__ = ("property_values",)
    property_values = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="propertyValues")
    """List of object property values"""


class QPMonitorExplanationType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("data_points", "breaching_query_logs")
    data_points = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(ExplanationDataPointType)),
        graphql_name="dataPoints",
    )
    """List of data points, with metrics that explain monitor evaluation"""

    breaching_query_logs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("QueryLogResultType")),
        graphql_name="breachingQueryLogs",
    )
    """List of breaching query logs"""


class QPMonitorSimulationType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("breaching_query_groups", "breaching_query_groups_daily_count")
    breaching_query_groups = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="breachingQueryGroups"
    )
    """List of breaching query groups"""

    breaching_query_groups_daily_count = sgqlc.types.Field(
        sgqlc.types.list_of(DataPoint), graphql_name="breachingQueryGroupsDailyCount"
    )
    """Daily count of breaching query groups over evaluation period"""


class QueriedTable(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("table", "count")
    table = sgqlc.types.Field(String, graphql_name="table")
    """Full table ID of the table"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Number of times the table was queried"""


class Query(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "list_custom_dashboards",
        "get_custom_dashboard",
        "load_custom_dashboard_widget_data",
        "lookup_custom_dashboard_time_series_id_by_mcon",
        "lookup_custom_dashboard_time_series_id_by_monitor",
        "get_agent_metadata",
        "get_agent_trace_tables",
        "get_traces_filters",
        "get_traces_filters_data",
        "get_traces",
        "get_table_monitor_metric",
        "get_tables_for_coverage_dashboard",
        "get_monitor_counts_by_creator",
        "get_monitor_counts_by_type",
        "get_logs_integrations",
        "generate_webhook_url",
        "get_user_id",
        "echo",
        "list_monitor_tags",
        "list_data_quality_dimensions",
        "list_tags",
        "list_data_operations_dashboards",
        "get_data_operations_dashboard",
        "get_monitors_score_trend",
        "get_platform_services",
        "get_migration_test_status",
        "get_platform_migration_test_status",
        "get_platform_migration_status",
        "get_caas_collection_node_parameters",
        "evaluate_data_source",
        "evaluate_sql_blocks",
        "generate_mc_sql",
        "get_sql_predicates",
        "get_transform_functions",
        "get_warehouse_supported_llm_models",
        "run_custom_query",
        "get_table_monitor_validation_statuses",
        "get_table_monitor_configuration",
        "get_default_monitor_configuration",
        "test_datadog_credentials",
        "get_datadog_integrations",
        "get_datadog_users",
        "get_datadog_teams",
        "get_datadog_services",
        "get_billing_credit_grants",
        "get_contract_commits",
        "get_billing_invoices",
        "get_billing_contract_invoices",
        "get_account_entitlements",
        "get_billing_monitor_usage",
        "get_field_metrics_info",
        "get_field_metric_data",
        "get_field_overview_properties",
        "get_data_profiler_monitor_recommendations",
        "get_data_explorer_comparison_dashboards",
        "get_comparable_dashboards",
        "get_data_explorer_table_summary_stats",
        "retrieve_table_data",
        "retrieve_widget_data",
        "get_data_profiler_widget_data",
        "get_data_explorer_table_metadata",
        "get_data_explorer_dashboard_for_table",
        "get_data_explorer_dashboards",
        "get_webex_integrations",
        "test_webex_credentials",
        "get_pipelines",
        "get_not_monitored_reason",
        "get_assets_usage",
        "get_monitored_table_rule_list",
        "get_monitored_tables_count_with_new_rule",
        "get_account_usage",
        "get_monitored_table_rule_job",
        "get_streaming_systems",
        "get_tableau_asset_warning_by_id",
        "get_adf_job_runs",
        "get_adf_task_runs",
        "get_databricks_job_runs",
        "get_databricks_task_runs",
        "get_etl_job",
        "get_etl_task",
        "get_etl_jobs",
        "get_etl_jobs_v2",
        "get_etl_tasks",
        "search_etl_jobs_and_tasks",
        "get_data_product",
        "get_data_product_v2",
        "get_data_products",
        "get_data_products_v2",
        "get_domain_filtered_data_products",
        "get_data_product_metrics",
        "get_data_product_metrics_v2",
        "get_data_product_asset_data",
        "get_data_product_upstream_counts",
        "get_data_product_audiences",
        "get_top_warehouse_for_data_product_mcons",
        "get_data_product_dry_run_counts",
        "parse_query",
        "ping_data_collector",
        "get_ms_teams_integrations",
        "get_ms_teams_channels",
        "get_github_integrations",
        "get_gitlab_integrations",
        "get_gitlab_integration",
        "get_github_pull_requests",
        "traverse_gitlab_projects",
        "get_github_pull_requests_for_table",
        "get_github_pull_requests_for_table_v2",
        "get_vcs_summary",
        "get_vcs_pull_requests",
        "get_gitlab_projects",
        "get_azure_devops_installations",
        "get_azure_devops_installation",
        "get_azure_devops_organization",
        "get_size_collection_configuration",
        "get_size_collection_query",
        "get_my_mcp_integration_keys",
        "get_opsgenie_integrations",
        "get_pagerduty_service_integrations",
        "get_volume_change_table_monitor",
        "get_ucs_table_monitor",
        "migrate_to_table_monitors",
        "get_freshness_table_monitor",
        "get_slack_users",
        "get_slack_user_groups",
        "list_slack_users",
        "list_slack_user_groups",
        "get_servicenow_incident_fields",
        "get_servicenow_users",
        "get_servicenow_integrations",
        "get_servicenow_reference_values",
        "test_servicenow_credentials",
        "test_azure_devops_credentials",
        "get_azure_devops_integrations",
        "get_azure_devops_projects",
        "get_azure_devops_work_item_types",
        "get_jira_integrations",
        "search_jira_users",
        "get_jira_users",
        "get_jira_statuses",
        "get_jira_teams",
        "get_jira_projects",
        "get_jira_issue_types",
        "test_jira_credentials",
        "get_jobs_performance_data",
        "get_jobs_performance_facets",
        "search_jobs_performance_facet",
        "get_tasks_performance_data",
        "get_query_perf_rule_execution_history_logs",
        "simulate_query_perf_monitor_evaluation",
        "get_query_perf_monitor_explanation_for_event",
        "get_query_perf_monitor_explanation",
        "get_indexed_field_specs",
        "get_query_logs",
        "get_query_log_timeline",
        "get_query_logs_facets_v2",
        "get_query_logs_facets",
        "get_query_runtime_percentile_timeseries",
        "get_query_performance_data",
        "get_top_query_groups",
        "get_aggregated_queries",
        "get_query_rcas",
        "get_query_dimensions",
        "get_query_text",
        "get_queried_tables",
        "get_notification_settings",
        "get_notification_audiences",
        "get_notification_audiences_count",
        "get_notification_audience_creators",
        "get_notification_counts",
        "get_notification_settings_for_ootb",
        "get_notification_settings_for_audiences",
        "get_collection_dataset_list",
        "get_collection_block_list",
        "get_allow_list",
        "get_workspaces_allow_list_for_power_bi_reports_collection",
        "get_asset_collection_preferences",
        "get_fivetran_connectors",
        "get_pii_filtering_preferences",
        "get_pii_filters",
        "get_pii_filter_metrics",
        "get_dbt_connections",
        "get_dbt_connection_details",
        "get_dbt_projects",
        "get_dbt_jobs",
        "get_dbt_nodes",
        "get_dbt_runs",
        "get_dbt_models",
        "get_dbt_model_results",
        "get_dbt_model_results_count",
        "get_dbt_node_results_count",
        "get_dbt_run_steps",
        "get_dbt_test_results_count",
        "get_dbt_test_results",
        "get_dbt_upload_url",
        "get_dbt_last_run_results",
        "get_dbt_job_executions",
        "get_exec_dashboard_metrics",
        "get_exec_dashboard_tables",
        "get_hosting_info",
        "get_deployment_info",
        "get_custom_users",
        "get_unified_users",
        "get_unified_user_assignments",
        "get_monte_carlo_config_templates",
        "export_monte_carlo_config_templates",
        "export_latest_version_monitor_replacement_templates",
        "export_dimension_tracking_monitor_migration_templates",
        "get_monte_carlo_config_template_update_state",
        "get_correlation_sampling_metadata",
        "detect_time_axis_intrinsic_delta",
        "perform_correlation_sampling",
        "perform_correlation_sampling_with_time_travel",
        "perform_field_health_sampling",
        "perform_field_health_sampling_v2",
        "perform_field_health_sampling_v3",
        "get_field_health_sampling_conditions",
        "get_rca_result",
        "get_rca_job_result",
        "get_incident_rcas",
        "get_alert_rcas",
        "get_table_rcas",
        "get_sensitivity",
        "thresholds",
        "get_thresholds",
        "get_data_maintenance_entries",
        "get_data_maintenance_entries_by_monitor",
        "get_data_maintenance_entries_by_mcon",
        "get_data_maintenance_holiday_codes",
        "get_data_maintenance_holiday_names",
        "get_table_columns_lineage",
        "get_derived_tables_partial_lineage",
        "get_parsed_query",
        "get_trace_tree_nodes",
        "get_agent_span_groups",
        "get_agent_span_sample",
        "get_agent_span_sample_v2",
        "evaluate_agent_monitor_data_source",
        "get_job_execution_history_logs",
        "get_job_executions",
        "get_table_monitor",
        "get_table_monitor_coverage",
        "get_monitors",
        "get_monitors_count",
        "get_monitor_namespaces",
        "get_monitor_warehouses",
        "get_monitor_projects",
        "get_monitor_datasets",
        "get_monitor_tables",
        "get_monitor_creators",
        "get_monitor_updaters",
        "get_monitor_queries",
        "test_monitor_queries",
        "get_notification_audiences_for_table",
        "get_monitor_comments",
        "get_all_user_defined_monitors_v2",
        "get_all_user_defined_monitors",
        "get_custom_rule",
        "get_custom_rules",
        "get_generated_rules",
        "get_circuit_breaker_rule_state",
        "get_circuit_breaker_rule_state_v2",
        "get_run_sql_rule_state",
        "get_tables_for_sql",
        "get_notification_settings_for_rules_with",
        "get_field_metric_query",
        "get_field_query",
        "get_query_template",
        "get_custom_rule_execution_analytics",
        "get_insights",
        "get_insight",
        "get_reports",
        "get_report_url",
        "get_lineage_node_block_pattern",
        "get_lineage_node_block_patterns",
        "get_lineage_node_replacement_rule",
        "get_lineage_node_replacement_rules",
        "get_lineage_node_collapsing_rules",
        "get_lineage_node_collapsing_rule",
        "simulate_lineage_node_replacement_rule",
        "get_catalog_object_metadata",
        "get_catalog_nav_level_nodes",
        "get_catalog_nav_grouped_nodes",
        "get_object_properties",
        "get_object_property_name_values",
        "get_object_property_names",
        "get_object_property_values",
        "get_monitor_labels",
        "monitor_labels",
        "get_account_monitor_labels",
        "get_custom_sql_templates",
        "get_active_monitors",
        "get_monitor_summary",
        "get_monitors_by_type",
        "get_monitor",
        "get_monitor_configuration",
        "get_monitor_scheduling_configuration",
        "get_time_axis_sql_expressions",
        "get_notification_settings_for_monitors_with",
        "get_custom_metric_test_query",
        "run_custom_metric_test_query",
        "get_segment_count_query",
        "run_segment_count_query",
        "evaluate_comparison_monitor_alert_conditions",
        "evaluate_comparisons",
        "evaluate_alert_conditions",
        "get_delta_logs",
        "get_job_schedules",
        "get_collector_job_limits",
        "get_data_assets_dashboard",
        "get_incident_dashboard_data",
        "get_incident_data_weekly",
        "get_alert_data_weekly",
        "get_monitor_dashboard_data",
        "get_blast_radius_direct_users_v2",
        "get_incident_tables",
        "get_incident_warehouse_tables",
        "get_alert_warehouse_tables",
        "get_schema_changes",
        "get_event_groups",
        "get_metric_event_groups",
        "get_events",
        "get_events_for_incidents",
        "get_events_for_alerts",
        "get_past_comments_for_alert",
        "get_comments_for_monitor_incidents",
        "get_event",
        "get_event_type_summary",
        "get_metric_comparison_events",
        "get_fh_events_by_monitor",
        "get_fh_events",
        "get_fh_events_where_condition_filter_values",
        "get_fh_events_where_condition_filter_values_paginated",
        "get_fh_events_metric_filter_values",
        "get_fh_events_field_filter_values",
        "get_incidents",
        "get_incidents_count_by_date",
        "get_incidents_filters",
        "get_incidents_filters_data",
        "get_incident_type_summary",
        "get_alert_type_summary",
        "get_incident_notification_settings_used",
        "get_alert_notification_settings_used",
        "get_slack_messages_for_incident",
        "get_slack_messages_for_alert",
        "get_slack_engagements_for_incident",
        "get_slack_engagements_for_alert",
        "get_past_slack_engagements_for_alert",
        "get_slack_engagements_for_incidents",
        "get_slack_engagements_for_alerts",
        "get_incident_timeline_events",
        "get_all_domains",
        "get_domain",
        "get_account_roles",
        "get_authorization_groups",
        "get_user_authorization",
        "get_authorization_provisioning",
        "get_access_request",
        "search",
        "search_tables_for_dynamic_schedule",
        "get_object",
        "get_metadata",
        "get_metrics_v4",
        "get_field_metric_definitions",
        "get_comparison_monitor_field_metric_definitions",
        "get_top_segmented_where_condition_labels",
        "get_segmented_where_condition_labels",
        "get_segmented_where_condition_label_count",
        "get_comparison_monitor_segment_labels",
        "get_comparison_monitor_segment_label_count",
        "get_downstream_bi",
        "get_downstream_impact_radius_summary",
        "get_downstream_reports",
        "get_downstream_report_owners",
        "get_downstream_report_types",
        "get_table_lineage",
        "get_table_lineage_v2",
        "get_table_lineage_v3",
        "get_table_lineage_v4",
        "get_table_lineage_jobs",
        "get_connected_mcon_lineage",
        "get_reduced_downstream_lineage",
        "get_external_source_paths_sample",
        "get_tableau_workbook_count",
        "get_query_list",
        "get_query_by_id",
        "get_query_by_query_hash",
        "get_query_data_by_query_hash",
        "get_query_data",
        "get_query_log_hashes_that_affect_these_tables",
        "get_related_users",
        "get_lineage_node_properties",
        "get_digraph",
        "get_custom_sql_output_sample",
        "get_custom_sql_output_download",
        "get_fh_sampling",
        "get_fh_reproduction_query",
        "test_sql_query_part",
        "test_sql_query_where_expression",
        "get_table_stats_v2",
        "get_table_stats",
        "get_resource",
        "get_resources",
        "get_table_fields_importance",
        "get_wildcard_templates",
        "run_sql_investigation_query",
        "get_warehouse_connections",
        "get_warehouse_tags_collection_setting",
        "get_lineage_node_types",
        "get_common_fields",
        "get_common_fields_v2",
        "get_tsa_availability",
        "get_user_settings",
        "get_shared_query",
        "get_user",
        "get_user_by_id",
        "get_warehouses",
        "get_should_show_onboarding",
        "get_warehouse",
        "get_collection_properties",
        "get_table",
        "get_tables",
        "get_tables_health",
        "get_bq_projects",
        "get_slack_oauth_url",
        "get_slack_channels",
        "get_slack_channels_v2",
        "get_projects",
        "get_datasets_by_uuid",
        "get_datasets",
        "get_field_bi_lineage",
        "get_event_muting_rules",
        "get_users_in_account",
        "get_users_basic_info",
        "get_invites_in_account",
        "get_token_metadata",
        "get_integration_keys",
        "test_existing_connection",
        "test_telnet_connection",
        "test_tcp_open_connection",
        "test_dns_lookup",
        "test_http_connection",
        "test_notification_integration",
        "get_databricks_warehouse_info",
        "validate_connection_type",
        "get_event_onboarding_data",
        "get_etl_containers",
        "get_account_feature_flag_status",
        "get_api_usage",
        "get_tables_upstream_counts",
        "get_tutorial_state",
        "get_data_lake_catalog_mappings",
        "get_supported_validations_v2",
        "get_supported_table_validations",
        "validate_data_asset_access",
        "validate_airflow_asset_access",
        "test_existing_connection_v2",
        "test_storage_access",
        "test_data_store_reachability",
        "test_agent_reachability",
        "list_projects",
        "list_datasets",
        "get_data_export_url",
        "get_generate_report_status",
        "evaluate_asset_selection",
        "get_account_audit_logs",
        "get_monitor_audit_logs",
        "get_monitored_rules_audit_logs",
        "get_alerts",
        "get_alert",
        "get_alert_description",
        "get_alerts_filters",
        "get_alerts_filters_data",
        "get_alerts_count_by_date",
        "get_alert_access_request",
        "get_collibra_ping",
        "get_collibra_monitor_note",
        "get_collibra_monitor_table_search_names",
        "get_collibra_domains_for_table_search_name",
        "get_alation_table_flags",
        "get_airflow_task_results",
        "get_airflow_task_stats",
        "get_airflow_tasks_for_source_and_destination_tables",
        "get_airflow_dag_runs",
        "get_airflow_capabilities",
        "get_ai_agent_config",
        "fix_sql_query",
        "create_sql_query",
        "get_agent_operation_logs",
        "get_gcp_agent_logs",
        "get_azure_agent_logs",
        "get_azure_agent_tasks_summary",
        "get_snowflake_agent_logs",
        "get_aws_agent_logs",
        "start_aws_logs_query",
        "stop_aws_logs_query",
        "get_aws_logs_query_results",
        "get_aws_agent_upgrade_logs",
        "get_aws_agent_infra_details",
        "get_account_secret",
        "get_account_secrets",
    )
    list_custom_dashboards = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardListConnection),
        graphql_name="listCustomDashboards",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) List all custom dashboards

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_custom_dashboard = sgqlc.types.Field(
        "CustomDashboard",
        graphql_name="getCustomDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dashboard_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dashboardId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get a specific custom dashboard

    Arguments:

    * `dashboard_id` (`UUID!`)None
    """

    load_custom_dashboard_widget_data = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(CustomDashboardWidgetContentData)),
        graphql_name="loadCustomDashboardWidgetData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dashboard_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dashboardId", default=None
                    ),
                ),
                (
                    "widget_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="widgetId", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Load the content data of a custom dashboard widget

    Arguments:

    * `dashboard_id` (`UUID!`)None
    * `widget_id` (`UUID!`)None
    * `start_time` (`DateTime!`)None
    * `end_time` (`DateTime!`)None
    """

    lookup_custom_dashboard_time_series_id_by_mcon = sgqlc.types.Field(
        CustomDashboardTimeSeriesLookup,
        graphql_name="lookupCustomDashboardTimeSeriesIdByMcon",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "metric_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metricName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Lookup the time series ID for a given MCON and
    metric

    Arguments:

    * `mcon` (`String!`)None
    * `metric_name` (`String!`)None
    """

    lookup_custom_dashboard_time_series_id_by_monitor = sgqlc.types.Field(
        CustomDashboardTimeSeriesLookup,
        graphql_name="lookupCustomDashboardTimeSeriesIdByMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "metric_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metricName", default=None
                    ),
                ),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """(experimental) Lookup the time series ID for a given monitor and
    metric

    Arguments:

    * `monitor_uuid` (`UUID!`)None
    * `metric_name` (`String!`)None
    * `field` (`String`)None
    * `where_condition` (`String`)None
    """

    get_agent_metadata = sgqlc.types.Field(
        sgqlc.types.list_of(AgentMetadata),
        graphql_name="getAgentMetadata",
        args=sgqlc.types.ArgDict(
            (
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),
            )
        ),
    )
    """(experimental) Get metadata about AI agents for agent
    observability

    Arguments:

    * `start_time` (`DateTime`): Filter spans with start_time >= this
      value
    * `domain_uuid` (`UUID`): Filter results to only include MCONs
      assigned to this domain UUID
    """

    get_agent_trace_tables = sgqlc.types.Field(
        sgqlc.types.list_of("AgentTraceTable"), graphql_name="getAgentTraceTables"
    )
    """(experimental) Get all agent trace tables"""

    get_traces_filters = sgqlc.types.Field(
        sgqlc.types.list_of("TraceFilter"), graphql_name="getTracesFilters"
    )
    """(experimental) Get metadata about filters that can be applied when
    requesting traces
    """

    get_traces_filters_data = sgqlc.types.Field(
        sgqlc.types.list_of("TraceFilterData"),
        graphql_name="getTracesFiltersData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "filters_request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(TraceFilterDataRequest)),
                        graphql_name="filtersRequest",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get filter values with counts for trace filters
    (for faceted search UI)

    Arguments:

    * `filters_request` (`[TraceFilterDataRequest]!`)None
    """

    get_traces = sgqlc.types.Field(
        "TraceConnection",
        graphql_name="getTraces",
        args=sgqlc.types.ArgDict(
            (
                (
                    "input",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GetTracesInput), graphql_name="input", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get traces from the agent_spans table with
    bidirectional cursor-based pagination. Traces are aggregations of
    individual spans grouped by trace_id. Supports sorting by multiple
    fields and filtering by agent name and time range.

    Arguments:

    * `input` (`GetTracesInput!`)None
    """

    get_table_monitor_metric = sgqlc.types.Field(
        "TableMonitorMetric",
        graphql_name="getTableMonitorMetric",
        args=sgqlc.types.ArgDict(
            (
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TableMonitorMetricType),
                        graphql_name="metric",
                        default=None,
                    ),
                ),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get a table monitor metric

    Arguments:

    * `metric` (`TableMonitorMetricType!`)None
    * `domain_ids` (`[UUID]`)None
    * `tags` (`[TagKeyValuePairInput]`)None
    * `data_product_ids` (`[UUID]`)None
    """

    get_tables_for_coverage_dashboard = sgqlc.types.Field(
        "SearchResponse",
        graphql_name="getTablesForCoverageDashboard",
        args=sgqlc.types.ArgDict(
            (
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=100)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TableMonitorMetricType),
                        graphql_name="metric",
                        default=None,
                    ),
                ),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get a list of tables

    Arguments:

    * `limit` (`Int`)None (default: `100`)
    * `offset` (`Int`)None
    * `metric` (`TableMonitorMetricType!`)None
    * `domain_ids` (`[UUID]`)None
    * `tags` (`[TagKeyValuePairInput]`)None
    * `data_product_ids` (`[UUID]`)None
    """

    get_monitor_counts_by_creator = sgqlc.types.Field(
        CreatorMonitorCountsResponse,
        graphql_name="getMonitorCountsByCreator",
        args=sgqlc.types.ArgDict(
            (
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=15)),
            )
        ),
    )
    """(experimental) Get paginated monitor counts grouped by creator

    Arguments:

    * `domain_ids` (`[UUID]`)None
    * `tags` (`[TagKeyValuePairInput]`)None
    * `data_product_ids` (`[UUID]`)None
    * `offset` (`Int`)None (default: `0`)
    * `limit` (`Int`)None (default: `15`)
    """

    get_monitor_counts_by_type = sgqlc.types.Field(
        MonitorTypeCountsResponse,
        graphql_name="getMonitorCountsByType",
        args=sgqlc.types.ArgDict(
            (
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=15)),
            )
        ),
    )
    """(experimental) Get paginated monitor counts grouped by monitor
    type

    Arguments:

    * `domain_ids` (`[UUID]`)None
    * `tags` (`[TagKeyValuePairInput]`)None
    * `data_product_ids` (`[UUID]`)None
    * `offset` (`Int`)None (default: `0`)
    * `limit` (`Int`)None (default: `15`)
    """

    get_logs_integrations = sgqlc.types.Field(
        sgqlc.types.list_of(LogsIntegrationOutput),
        graphql_name="getLogsIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """(general availability) Get the configured Logs integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    generate_webhook_url = sgqlc.types.Field(
        GenerateWebhookUrl,
        graphql_name="generateWebhookUrl",
        args=sgqlc.types.ArgDict(
            (
                (
                    "service",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(WebhookServiceTypes),
                        graphql_name="service",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Generate a webhook URL for an external service

    Arguments:

    * `service` (`WebhookServiceTypes!`): The external service
    """

    get_user_id = sgqlc.types.Field(String, graphql_name="getUserId")
    """(experimental) Gets the current user's id"""

    echo = sgqlc.types.Field(
        String,
        graphql_name="echo",
        args=sgqlc.types.ArgDict(
            (("input", sgqlc.types.Arg(String, graphql_name="input", default=None)),)
        ),
    )
    """(experimental) Echos the input string

    Arguments:

    * `input` (`String`)None
    """

    list_monitor_tags = sgqlc.types.Field(
        ListMonitorTagsOutput,
        graphql_name="listMonitorTags",
        args=sgqlc.types.ArgDict(
            (
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List monitor tags.

    Arguments:

    * `page_size` (`Int`): Page size for each call. If not set, by
      default it's 50.
    * `offset` (`Int`): Offset that indicates where to start returning
      the result.
    """

    list_data_quality_dimensions = sgqlc.types.Field(
        ListDataQualityDimensionsOutput, graphql_name="listDataQualityDimensions"
    )
    """(experimental) List all data quality dimensions."""

    list_tags = sgqlc.types.Field(
        ListTagsOutput,
        graphql_name="listTags",
        args=sgqlc.types.ArgDict(
            (
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("tag_type", sgqlc.types.Arg(TagType, graphql_name="tagType", default=None)),
            )
        ),
    )
    """(experimental) List tags.

    Arguments:

    * `page_size` (`Int`): Page size for each call. If not set, by
      default it's 50.
    * `offset` (`Int`): Offset that indicates where to start returning
      the result.
    * `tag_type` (`TagType`): if set, we'd return tags only of that
      type.
    """

    list_data_operations_dashboards = sgqlc.types.Field(
        ListDataOperationsDashboardsOutput,
        graphql_name="listDataOperationsDashboards",
        args=sgqlc.types.ArgDict(
            (
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
                ("cursor", sgqlc.types.Arg(String, graphql_name="cursor", default=None)),
            )
        ),
    )
    """(experimental) List data operations dashboards.

    Arguments:

    * `page_size` (`Int`): Page size for each call. If not set, by
      default it's 50.
    * `cursor` (`String`): cursor for next page of data operations
      dashboards.
    """

    get_data_operations_dashboard = sgqlc.types.Field(
        DataOperationsDashboardOutput,
        graphql_name="getDataOperationsDashboard",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_operations_dashboard_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID),
                        graphql_name="dataOperationsDashboardUuid",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get data operations dashboard by uuid.

    Arguments:

    * `data_operations_dashboard_uuid` (`UUID!`): UUID of the data
      operations Dashboard.
    """

    get_monitors_score_trend = sgqlc.types.Field(
        sgqlc.types.list_of(MonitorScoreTrendType),
        graphql_name="getMonitorsScoreTrend",
        args=sgqlc.types.ArgDict(
            (
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="tags",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(ConsolidatedMonitorStatusType)),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get monitors score trend

    Arguments:

    * `domain_id` (`UUID`): Domain uuid to filter by
    * `tags` (`[TagKeyValuePairInput!]`): Filter by monitor tags.
    * `consolidated_status_types`
      (`[ConsolidatedMonitorStatusType!]`): Type of consolidated
      monitor status to filter by, default all
    """

    get_platform_services = sgqlc.types.Field(
        sgqlc.types.list_of(PlatformServiceObject),
        graphql_name="getPlatformServices",
        args=sgqlc.types.ArgDict(
            (
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
                ("agent_uuid", sgqlc.types.Arg(UUID, graphql_name="agentUuid", default=None)),
                (
                    "deployment_type",
                    sgqlc.types.Arg(
                        DataCollectorDeploymentTypeExtendedEnum,
                        graphql_name="deploymentType",
                        default=None,
                    ),
                ),
                (
                    "connection_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConnectionTypeEnum),
                        graphql_name="connectionTypes",
                        default=None,
                    ),
                ),
                (
                    "connection_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="connectionUuids", default=None
                    ),
                ),
                (
                    "supports_connection_type",
                    sgqlc.types.Arg(
                        ConnectionTypeEnum, graphql_name="supportsConnectionType", default=None
                    ),
                ),
                (
                    "supports_agent_type",
                    sgqlc.types.Arg(AgentTypeEnum, graphql_name="supportsAgentType", default=None),
                ),
                (
                    "supports_agent_platform",
                    sgqlc.types.Arg(
                        PlatformTypeEnum, graphql_name="supportsAgentPlatform", default=None
                    ),
                ),
            )
        ),
    )
    """List of platform services linked to the account

    Arguments:

    * `service_uuid` (`UUID`): UUID of the platform service to return
    * `agent_uuid` (`UUID`): UUID of the active agent in the platform
      service to return
    * `deployment_type` (`DataCollectorDeploymentTypeExtendedEnum`):
      Deployment type of the platform service to return
    * `connection_types` (`[ConnectionTypeEnum]`): Only return
      platform services containing connections with these types
    * `connection_uuids` (`[UUID]`): Only return platform services
      containing connections with these UUIDs
    * `supports_connection_type` (`ConnectionTypeEnum`): Only return
      platform services supporting the specified connection type
    * `supports_agent_type` (`AgentTypeEnum`): Only return platform
      services supporting the specified agent type
    * `supports_agent_platform` (`PlatformTypeEnum`): Only return
      platform services supporting the specified platform type
    """

    get_migration_test_status = sgqlc.types.Field(
        DcMigrationStatusResponse,
        graphql_name="getMigrationTestStatus",
        args=sgqlc.types.ArgDict(
            (
                (
                    "migration_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="migrationUuid", default=None
                    ),
                ),
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """DC migration status

    Arguments:

    * `migration_uuid` (`UUID!`): UUID of the migration to check
    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    get_platform_migration_test_status = sgqlc.types.Field(
        PlatformMigrationTestStatusResponse,
        graphql_name="getPlatformMigrationTestStatus",
        args=sgqlc.types.ArgDict(
            (
                (
                    "migration_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="migrationUuid", default=None
                    ),
                ),
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Platform migration test status

    Arguments:

    * `migration_uuid` (`UUID!`): UUID of the migration to check
    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    get_platform_migration_status = sgqlc.types.Field(
        PlatformMigrationStatusResponse,
        graphql_name="getPlatformMigrationStatus",
        args=sgqlc.types.ArgDict(
            (
                (
                    "migration_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="migrationUuid", default=None
                    ),
                ),
                ("dc_uuid", sgqlc.types.Arg(UUID, graphql_name="dcUuid", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Platform migration status

    Arguments:

    * `migration_uuid` (`UUID!`): UUID of the migration to check
    * `dc_uuid` (`UUID`): [Deprecated] Use serviceUuid instead
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    get_caas_collection_node_parameters = sgqlc.types.Field(
        CaasCollectionNodeParameters,
        graphql_name="getCaasCollectionNodeParameters",
        args=sgqlc.types.ArgDict(
            (("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),)
        ),
    )
    """Returns the parameters for the collection node associated to the
    specified service.

    Arguments:

    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    evaluate_data_source = sgqlc.types.Field(
        DataSourceEvaluationResult,
        graphql_name="evaluateDataSource",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_source_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceType),
                        graphql_name="dataSourceType",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("sql", sgqlc.types.Arg(String, graphql_name="sql", default=None)),
                (
                    "transforms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TransformInput)),
                        graphql_name="transforms",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Evaluates a data source

    Arguments:

    * `data_source_type` (`DataSourceType!`): Data source type
    * `connection_id` (`UUID`): Connection UUID
    * `dw_id` (`UUID`): Warehouse UUID
    * `mcon` (`String`): MCON to evaluate
    * `sql` (`String`): SQL to evaluate
    * `transforms` (`[TransformInput!]`): Transforms to apply to the
      data source
    """

    evaluate_sql_blocks = sgqlc.types.Field(
        "SqlBlockEvaluationResult",
        graphql_name="evaluateSqlBlocks",
        args=sgqlc.types.ArgDict(
            (
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "sql_blocks",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CustomRuleSqlBlocksInput),
                        graphql_name="sqlBlocks",
                        default=None,
                    ),
                ),
                ("count_rows", sgqlc.types.Arg(Boolean, graphql_name="countRows", default=False)),
                (
                    "validate_custom_sql",
                    sgqlc.types.Arg(Boolean, graphql_name="validateCustomSql", default=True),
                ),
                (
                    "resolve_transform_queries",
                    sgqlc.types.Arg(Boolean, graphql_name="resolveTransformQueries", default=False),
                ),
            )
        ),
    )
    """(experimental) Evaluates the provided SQL blocks

    Arguments:

    * `connection_id` (`UUID`): Connection UUID
    * `dw_id` (`UUID`): Warehouse UUID
    * `data_source` (`DataSourceUnionInput!`): The data source
    * `sql_blocks` (`CustomRuleSqlBlocksInput!`): The SQL blocks
    * `count_rows` (`Boolean`): Whether to count the number of rows
      returned by the SQL blocks (default: `false`)
    * `validate_custom_sql` (`Boolean`): Whether to validate the
      custom and generated SQL by running it against the data
      warehouse (default: `true`)
    * `resolve_transform_queries` (`Boolean`): return a query for each
      transform in the data source. (default: `false`)
    """

    generate_mc_sql = sgqlc.types.Field(
        McSqlResult,
        graphql_name="generateMcSql",
        args=sgqlc.types.ArgDict(
            (
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "sql_blocks",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CustomRuleSqlBlocksInput),
                        graphql_name="sqlBlocks",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Returns a presentable format of alert conditions

    Arguments:

    * `connection_id` (`UUID`): Connection UUID
    * `dw_id` (`UUID`): Warehouse UUID
    * `data_source` (`DataSourceUnionInput!`): The data source
    * `sql_blocks` (`CustomRuleSqlBlocksInput!`): The SQL blocks
    """

    get_sql_predicates = sgqlc.types.Field(
        sgqlc.types.list_of(Predicate), graphql_name="getSqlPredicates"
    )

    get_transform_functions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("TransformFunction")),
        graphql_name="getTransformFunctions",
    )
    """(experimental) Gets all available transform functions"""

    get_warehouse_supported_llm_models = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(LLMModel)),
        graphql_name="getWarehouseSupportedLlmModels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default=None),
                ),
            )
        ),
    )
    """(experimental) Gets all available LLM models across warehouse
    types

    Arguments:

    * `warehouse_uuid` (`UUID`): Warehouse UUID. If provided, the
      connection type will be ignored.
    * `connection_type` (`String`): connection type, for example
      "snowflake", "bigquery", etc.
    """

    run_custom_query = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="runCustomQuery",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(QueryResultType, graphql_name="queryResultType", default=None),
                ),
            )
        ),
    )
    """(experimental) Run a SQL query. Results will only be returned if
    sampling is enabled and allowed for the current user.

    Arguments:

    * `dw_id` (`UUID`): warehouse UUID
    * `connection_id` (`UUID`): connection UUID
    * `query` (`String`)None
    * `variables` (`JSONString`): If the query is using variables,
      values to use when running the query.
    * `query_result_type` (`QueryResultType`): Query result type. Pass
      a value if you want to validate the query conforms to the
      expected result type before returning a result. By default, it
      returnsa COUNT(*) of the provided query.
    """

    get_table_monitor_validation_statuses = sgqlc.types.Field(
        "TableMonitorStatuses",
        graphql_name="getTableMonitorValidationStatuses",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
            )
        ),
    )
    """Fetches the status of all validations performed on account tables

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    """

    get_table_monitor_configuration = sgqlc.types.Field(
        "TableMonitorConfiguration",
        graphql_name="getTableMonitorConfiguration",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """Fetches the suggested configuration for a table

    Arguments:

    * `mcon` (`String`)None
    """

    get_default_monitor_configuration = sgqlc.types.Field(
        "TableMonitorConfiguration",
        graphql_name="getDefaultMonitorConfiguration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Fetches monitor configuration for a table

    Arguments:

    * `mcon` (`String!`)None
    """

    test_datadog_credentials = sgqlc.types.Field(
        "TestDatadogCredentialsOutput",
        graphql_name="testDatadogCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "site",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="site", default=None
                    ),
                ),
                (
                    "api_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="apiKey", default=None
                    ),
                ),
                (
                    "application_key",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="applicationKey", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Test the Datadog connection credentials

    Arguments:

    * `site` (`String!`): Datadog site (e.g. datadoghq.com)
    * `api_key` (`String!`): Datadog API key
    * `application_key` (`String!`): Datadog Application key
    """

    get_datadog_integrations = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(DatadogIntegrationOutput)),
        graphql_name="getDatadogIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """(experimental) Get Datadog integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    get_datadog_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(DatadogUserOutput)),
        graphql_name="getDatadogUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
            )
        ),
    )
    """(experimental) Get the list of Datadog users

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `query` (`String`): A query to filter users
    """

    get_datadog_teams = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(DatadogTeamOutput)),
        graphql_name="getDatadogTeams",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None),
                ),
                (
                    "integration_site",
                    sgqlc.types.Arg(String, graphql_name="integrationSite", default=None),
                ),
                (
                    "integration_api_key",
                    sgqlc.types.Arg(String, graphql_name="integrationApiKey", default=None),
                ),
                (
                    "integration_application_key",
                    sgqlc.types.Arg(String, graphql_name="integrationApplicationKey", default=None),
                ),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                (
                    "ids",
                    sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="ids", default=None),
                ),
                ("page_number", sgqlc.types.Arg(Int, graphql_name="pageNumber", default=None)),
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
            )
        ),
    )
    """(experimental) Get the list of Datadog incident teams. Either
    provide integration_id OR (integration_site, integration_api_key,
    integration_application_key) for testing credentials.

    Arguments:

    * `integration_id` (`UUID`): The integration ID (required if not
      using direct credentials)
    * `integration_site` (`String`): Datadog site (e.g. datadoghq.com)
      - for testing without integration
    * `integration_api_key` (`String`): Datadog API key - for testing
      without integration
    * `integration_application_key` (`String`): Datadog Application
      key - for testing without integration
    * `query` (`String`): A query to filter teams
    * `ids` (`[String]`): List of team ids to filter by
    * `page_number` (`Int`): Page number (default: 0)
    * `page_size` (`Int`): Page size (default: 100)
    """

    get_datadog_services = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(DatadogServiceOutput)),
        graphql_name="getDatadogServices",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None),
                ),
                (
                    "integration_site",
                    sgqlc.types.Arg(String, graphql_name="integrationSite", default=None),
                ),
                (
                    "integration_api_key",
                    sgqlc.types.Arg(String, graphql_name="integrationApiKey", default=None),
                ),
                (
                    "integration_application_key",
                    sgqlc.types.Arg(String, graphql_name="integrationApplicationKey", default=None),
                ),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                ("page_number", sgqlc.types.Arg(Int, graphql_name="pageNumber", default=None)),
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
            )
        ),
    )
    """(experimental) Get the list of Datadog incident services. Either
    provide integration_id OR (integration_site, integration_api_key,
    integration_application_key) for testing credentials.

    Arguments:

    * `integration_id` (`UUID`): The integration ID (required if not
      using direct credentials)
    * `integration_site` (`String`): Datadog site (e.g. datadoghq.com)
      - for testing without integration
    * `integration_api_key` (`String`): Datadog API key - for testing
      without integration
    * `integration_application_key` (`String`): Datadog Application
      key - for testing without integration
    * `query` (`String`): A query to filter services
    * `page_number` (`Int`): Page number (default: 0)
    * `page_size` (`Int`): Page size (default: 100)
    """

    get_billing_credit_grants = sgqlc.types.Field(
        BillingCreditGrantResults,
        graphql_name="getBillingCreditGrants",
        args=sgqlc.types.ArgDict(
            (("end_cursor", sgqlc.types.Arg(String, graphql_name="endCursor", default=None)),)
        ),
    )
    """Get a list of credit grants for the account. Expect the currency
    for monetary values to be in USD (cents).

    Arguments:

    * `end_cursor` (`String`): Cursor used to get results from the
      next page
    """

    get_contract_commits = sgqlc.types.Field(
        ContractCommitResults, graphql_name="getContractCommits"
    )
    """(general availability) Get a list of commits for all contracts."""

    get_billing_invoices = sgqlc.types.Field(
        BillingInvoiceResults,
        graphql_name="getBillingInvoices",
        args=sgqlc.types.ArgDict(
            (
                ("end_cursor", sgqlc.types.Arg(String, graphql_name="endCursor", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=12)),
                (
                    "sort",
                    sgqlc.types.Arg(BillingInvoicesSort, graphql_name="sort", default="date_desc"),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "status",
                    sgqlc.types.Arg(BillingInvoiceStatus, graphql_name="status", default=None),
                ),
            )
        ),
    )
    """Get a list of invoices for the account. Expect the currency for
    monetary values to be in USD (cents).

    Arguments:

    * `end_cursor` (`String`): Cursor used to get results from the
      next page
    * `limit` (`Int`): Limit the number of results returned. Values
      1-100 accepted. (default: `12`)
    * `sort` (`BillingInvoicesSort`): Sort invoices by issued date.
      (default: `"date_desc"`)
    * `start_time` (`DateTime`): Filter invoices by billing periods
      that start at or after this time.
    * `end_time` (`DateTime`): Filter invoices by billing periods that
      end before this time.
    * `status` (`BillingInvoiceStatus`)None
    """

    get_billing_contract_invoices = sgqlc.types.Field(
        BillingContractInvoiceResults,
        graphql_name="getBillingContractInvoices",
        args=sgqlc.types.ArgDict(
            (
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=12)),
                (
                    "sort",
                    sgqlc.types.Arg(BillingInvoicesSort, graphql_name="sort", default="date_desc"),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "status",
                    sgqlc.types.Arg(BillingInvoiceStatus, graphql_name="status", default=None),
                ),
            )
        ),
    )
    """(general availability) Get a list of invoices for the account.

    Arguments:

    * `limit` (`Int`): Limit the number of results returned. Values
      1-100 accepted. (default: `12`)
    * `sort` (`BillingInvoicesSort`): Sort invoices by issued date.
      (default: `"date_desc"`)
    * `start_time` (`DateTime`): Filter invoices by billing periods
      that start at or after this time.
    * `end_time` (`DateTime`): Filter invoices by billing periods that
      end before this time.
    * `status` (`BillingInvoiceStatus`)None
    """

    get_account_entitlements = sgqlc.types.Field(
        AccountEntitlementsInfo,
        graphql_name="getAccountEntitlements",
        args=sgqlc.types.ArgDict(
            (("refresh", sgqlc.types.Arg(Boolean, graphql_name="refresh", default=False)),)
        ),
    )
    """Arguments:

    * `refresh` (`Boolean`)None (default: `false`)
    """

    get_billing_monitor_usage = sgqlc.types.Field(
        BillingMonitorUsageResults,
        graphql_name="getBillingMonitorUsage",
        args=sgqlc.types.ArgDict(
            (
                (
                    "start_on",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startOn", default=None
                    ),
                ),
                (
                    "end_before",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endBefore", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Get monitor usage data.

    Arguments:

    * `start_on` (`DateTime!`): Start date, inclusive.
    * `end_before` (`DateTime!`): End date, not inclusive.
    """

    get_field_metrics_info = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(MetricInfo)),
        graphql_name="getFieldMetricsInfo",
        args=sgqlc.types.ArgDict(
            (("field_type", sgqlc.types.Arg(String, graphql_name="fieldType", default=None)),)
        ),
    )
    """(experimental) Gets Metrics Supported by Data Profiler.

    Arguments:

    * `field_type` (`String`): field_type to fetch type specific
      properties. types supported - ['numeric', 'string', 'time',
      'date', 'boolean', 'time_of_day', 'unknown']
    """

    get_field_metric_data = sgqlc.types.Field(
        FieldMetricDataResponse,
        graphql_name="getFieldMetricData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatasetInput), graphql_name="dataset", default=None
                    ),
                ),
                ("field_name", sgqlc.types.Arg(String, graphql_name="fieldName", default=None)),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AggregateMetricType),
                        graphql_name="metric",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get field metric data for charting

    Arguments:

    * `dataset` (`DatasetInput!`)None
    * `field_name` (`String`): Field name to fetch properties
    * `metric` (`AggregateMetricType!`): Get data for Metric
    """

    get_field_overview_properties = sgqlc.types.Field(
        FieldOverviewResponse,
        graphql_name="getFieldOverviewProperties",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatasetInput), graphql_name="dataset", default=None
                    ),
                ),
                (
                    "field_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="fieldName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) get field overview properties

    Arguments:

    * `dataset` (`DatasetInput!`)None
    * `field_name` (`String!`): field_name to fetch properties
    """

    get_data_profiler_monitor_recommendations = sgqlc.types.Field(
        MonitorRecommendationsResponse,
        graphql_name="getDataProfilerMonitorRecommendations",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MonitorRecommendationsInput),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) get monitor recommendations for data explorer
    widget.

    Arguments:

    * `request` (`MonitorRecommendationsInput!`)None
    """

    get_data_explorer_comparison_dashboards = sgqlc.types.Field(
        DataExplorerComparisonDashboardTypeConnection,
        graphql_name="getDataExplorerComparisonDashboards",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuids",
                    sgqlc.types.Arg(sgqlc.types.list_of(UUID), graphql_name="uuids", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `uuids` (`[UUID]`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_comparable_dashboards = sgqlc.types.Field(
        sgqlc.types.list_of(ComparableDashboardType),
        graphql_name="getComparableDashboards",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `uuid` (`UUID!`)None
    """

    get_data_explorer_table_summary_stats = sgqlc.types.Field(
        "TableSummaryStatsType",
        graphql_name="getDataExplorerTableSummaryStats",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DatasetInput), graphql_name="dataset", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `dataset` (`DatasetInput!`)None
    """

    retrieve_table_data = sgqlc.types.Field(
        DataResponseType,
        graphql_name="retrieveTableData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(RetrieveTableDataRequestInput),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`RetrieveTableDataRequestInput!`)None
    """

    retrieve_widget_data = sgqlc.types.Field(
        DataResponseType,
        graphql_name="retrieveWidgetData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(RetrieveWidgetDataRequestInput),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`RetrieveWidgetDataRequestInput!`)None
    """

    get_data_profiler_widget_data = sgqlc.types.Field(
        "WidgetDataResponseType",
        graphql_name="getDataProfilerWidgetData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataProfilerWidgetDataInput),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) This is to fetch widget data in Data Explorer.

    Arguments:

    * `request` (`DataProfilerWidgetDataInput!`)None
    """

    get_data_explorer_table_metadata = sgqlc.types.Field(
        "TableMetadataType",
        graphql_name="getDataExplorerTableMetadata",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
            )
        ),
    )
    """Arguments:

    * `mcon` (`String!`)None
    * `connection_id` (`UUID`): Optional connection ID to use for
      queries
    """

    get_data_explorer_dashboard_for_table = sgqlc.types.Field(
        "DataExplorerDashboardType",
        graphql_name="getDataExplorerDashboardForTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Get (or create a default) data explorer dashboard for a table

    Arguments:

    * `mcon` (`String!`): MCON of table
    """

    get_data_explorer_dashboards = sgqlc.types.Field(
        DataExplorerDashboardTypeConnection,
        graphql_name="getDataExplorerDashboards",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuids",
                    sgqlc.types.Arg(sgqlc.types.list_of(UUID), graphql_name="uuids", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get data explorer dashboards

    Arguments:

    * `uuids` (`[UUID]`): UUIDs to filter by
    * `mcon` (`String`): MCON to filter by
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_webex_integrations = sgqlc.types.Field(
        sgqlc.types.list_of("WebexIntegrationOutput"),
        graphql_name="getWebexIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """Get the configured Webex integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    test_webex_credentials = sgqlc.types.Field(
        "WebexTestCredentialsOutput",
        graphql_name="testWebexCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "bot_token",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="botToken", default=None
                    ),
                ),
            )
        ),
    )
    """Test the Webex connection credentials

    Arguments:

    * `bot_token` (`String!`): The Webex bot token for basic
      authentication
    """

    get_pipelines = sgqlc.types.Field(
        PipelinesData,
        graphql_name="getPipelines",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceUuid", default=None
                    ),
                ),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """Fetches the pipelines located in the warehouses

    Arguments:

    * `resource_uuid` (`UUID!`): warehouse unique identifier
    * `search` (`String`): String to search for in the pipeline
      display name
    * `offset` (`Int`): Paging offset
    * `limit` (`Int`): Number of results to return from offset
    """

    get_not_monitored_reason = sgqlc.types.Field(
        NotMonitoredReason,
        graphql_name="getNotMonitoredReason",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Explain a reason behind an asset not being monitored

    Arguments:

    * `mcon` (`String!`): MCON of the asset
    """

    get_assets_usage = sgqlc.types.Field(
        AssetsUsageResults,
        graphql_name="getAssetsUsage",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("parent_mcon", sgqlc.types.Arg(String, graphql_name="parentMcon", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                (
                    "display_name_contains",
                    sgqlc.types.Arg(String, graphql_name="displayNameContains", default=None),
                ),
                (
                    "filter_options",
                    sgqlc.types.Arg(
                        AssetsUsageFilterOptions, graphql_name="filterOptions", default=None
                    ),
                ),
                (
                    "sort_options",
                    sgqlc.types.Arg(AssetsSortInput, graphql_name="sortOptions", default=None),
                ),
            )
        ),
    )
    """Use this to get a list of assets. The response will only contain
    assets of one type. The asset hierarchy is warehouses > databases
    > schemas > tables. If mcon is given, the response will only
    contain this object. To get all warehouses, omit both mcon and
    parentMcon. This assumes the parent to be the account. To get all
    databases/projects under a warehouse, provide the mcon of the
    warehouse. To get all schemas/datasets under a database, provide
    the mcon of the database. To get all tables under a schema,
    provide the mcon of the schema.

    Arguments:

    * `mcon` (`String`): Filter by mcon, returns this single object.
      Include this or parent_mcon.If neither mcon nor parent_mcon is
      given, will return warehouses.
    * `parent_mcon` (`String`): Only include children of this object.
      Include this or mcon.If neither mcon nor parent_mcon is given,
      will return warehouses.
    * `offset` (`Int`): Starting node index for current page.
    * `limit` (`Int`): Max nodes to get for page.
    * `display_name_contains` (`String`): To search a substring of an
      asset's display name.
    * `filter_options` (`AssetsUsageFilterOptions`): To filter results
      by only ingested/not ingested/monitored/not monitored tables.
    * `sort_options` (`AssetsSortInput`): To sort results by a field.
      Default is ascending order.
    """

    get_monitored_table_rule_list = sgqlc.types.Field(
        sgqlc.types.list_of(MonitoredTableRuleObject),
        graphql_name="getMonitoredTableRuleList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
            )
        ),
    )
    """List of rules for deciding which tables are monitored for a given
    project & dataset scope

    Arguments:

    * `dw_id` (`UUID!`): Warehouse ID to filter the rules
    * `project` (`String`): Project/database name to filter the rules.
      If not provided, return warehouse level rules.
    * `dataset` (`String`): Dataset/schema name to filter the rules.
      If not provided, return project level rules.
    """

    get_monitored_tables_count_with_new_rule = sgqlc.types.Field(
        AdditionalMonitoredTablesCountOutput,
        graphql_name="getMonitoredTablesCountWithNewRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                (
                    "rule",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MonitoredTableRuleInput),
                        graphql_name="rule",
                        default=None,
                    ),
                ),
                (
                    "domain_restrictions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainRestrictions",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Simulates applying a new rule and returns number of
    additional tables monitored. Does not support exclusion rules.

    Arguments:

    * `dw_id` (`UUID!`): Rules apply to tables in this warehouse
    * `project` (`String`): Rules apply to tables in this
      project/database
    * `dataset` (`String`): Rules apply to tables in this
      dataset/schema
    * `rule` (`MonitoredTableRuleInput!`): New monitoring rule
    * `domain_restrictions` (`[UUID!]`): Filter by domain UUIDs.Only
      count tables that belong to the specified domains. If not
      provided, all tables are considered.
    """

    get_account_usage = sgqlc.types.Field(
        sgqlc.types.list_of(AccountUsageObject),
        graphql_name="getAccountUsage",
        args=sgqlc.types.ArgDict(
            (
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
            )
        ),
    )
    """List of account usages per account.

    Arguments:

    * `start_time` (`DateTime`): Start time is inclusive (timezone in
      UTC) to get time-bound values for.
    * `end_time` (`DateTime`): End time is inclusive (timezone in UTC)
      to get time-bound values for.
    """

    get_monitored_table_rule_job = sgqlc.types.Field(
        MonitoredTableRuleJobStatusObject,
        graphql_name="getMonitoredTableRuleJob",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="jobId", default=None),
                ),
            )
        ),
    )
    """Get the job for updating monitored table rules

    Arguments:

    * `job_id` (`UUID!`): Job ID to get the job details
    """

    get_streaming_systems = sgqlc.types.Field(
        sgqlc.types.list_of("StreamingSystemWithClusters"),
        graphql_name="getStreamingSystems",
        args=sgqlc.types.ArgDict(
            (
                (
                    "include_clusters",
                    sgqlc.types.Arg(Boolean, graphql_name="includeClusters", default=None),
                ),
            )
        ),
    )
    """Gets streaming systems under an account.

    Arguments:

    * `include_clusters` (`Boolean`)None
    """

    get_tableau_asset_warning_by_id = sgqlc.types.Field(
        GetTableauAssetWarningByIdResponse,
        graphql_name="getTableauAssetWarningById",
        args=sgqlc.types.ArgDict(
            (
                (
                    "bi_container_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="biContainerId", default=None
                    ),
                ),
                (
                    "tableau_warning_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tableauWarningId", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `bi_container_id` (`UUID!`): UUID of the Tableau container for
      which this warning is being created.
    * `tableau_warning_id` (`String!`): The Tableau Data Quality
      Warning ID.
    """

    get_adf_job_runs = sgqlc.types.Field(
        AdfJobRunsConnection,
        graphql_name="getAdfJobRuns",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("job_mcon", sgqlc.types.Arg(String, graphql_name="jobMcon", default=None)),
                ("table_mcon", sgqlc.types.Arg(String, graphql_name="tableMcon", default=None)),
                ("from_date", sgqlc.types.Arg(DateTime, graphql_name="fromDate", default=None)),
                ("to_date", sgqlc.types.Arg(DateTime, graphql_name="toDate", default=None)),
            )
        ),
    )
    """(experimental) List of runs for a given job

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `job_mcon` (`String`): Job MCON to filter by
    * `table_mcon` (`String`): Table MCON to filter by
    * `from_date` (`DateTime`): Filter date range start
    * `to_date` (`DateTime`): Filter date range end
    """

    get_adf_task_runs = sgqlc.types.Field(
        sgqlc.types.list_of("AdfTaskRun"),
        graphql_name="getAdfTaskRuns",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobMcon", default=None
                    ),
                ),
                (
                    "job_run_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobRunId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) List of runs for a given job

    Arguments:

    * `job_mcon` (`String!`): Job MCON to filter by
    * `job_run_id` (`String!`): Job Run Id to filter by
    """

    get_databricks_job_runs = sgqlc.types.Field(
        DatabricksJobRunsConnection,
        graphql_name="getDatabricksJobRuns",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("job_mcon", sgqlc.types.Arg(String, graphql_name="jobMcon", default=None)),
                ("table_mcon", sgqlc.types.Arg(String, graphql_name="tableMcon", default=None)),
                ("from_date", sgqlc.types.Arg(DateTime, graphql_name="fromDate", default=None)),
                ("to_date", sgqlc.types.Arg(DateTime, graphql_name="toDate", default=None)),
            )
        ),
    )
    """(experimental) List of runs for a given job

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `job_mcon` (`String`): Job MCON to filter by
    * `table_mcon` (`String`): Table MCON to filter by
    * `from_date` (`DateTime`): Filter date range start
    * `to_date` (`DateTime`): Filter date range end
    """

    get_databricks_task_runs = sgqlc.types.Field(
        sgqlc.types.list_of("DatabricksTaskRun"),
        graphql_name="getDatabricksTaskRuns",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobMcon", default=None
                    ),
                ),
                (
                    "job_run_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobRunId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) List of runs for a given job

    Arguments:

    * `job_mcon` (`String!`): Job MCON to filter by
    * `job_run_id` (`String!`): Job Run Id to filter by
    """

    get_etl_job = sgqlc.types.Field(
        "ETLJobUnionType",
        graphql_name="getEtlJob",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Get information about a job

    Arguments:

    * `mcon` (`String!`): Mcon for job to get details for
    """

    get_etl_task = sgqlc.types.Field(
        "ETLTaskUnionType",
        graphql_name="getEtlTask",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Get information about a task

    Arguments:

    * `mcon` (`String!`): Mcon for task to get details for
    """

    get_etl_jobs = sgqlc.types.Field(
        ETLJobsType,
        graphql_name="getEtlJobs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "first",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="first", default=None),
                ),
                (
                    "offset",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="offset", default=None),
                ),
                ("resource_uuid", sgqlc.types.Arg(UUID, graphql_name="resourceUuid", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
            )
        ),
    )
    """Deprecated - use getEtlJobsV2 instead

    Arguments:

    * `first` (`Int!`): Page size
    * `offset` (`Int!`): Page offset
    * `resource_uuid` (`UUID`): Filter by ETL container
    * `mcons` (`[String]`): Filter by mcons
    """

    get_etl_jobs_v2 = sgqlc.types.Field(
        ETLJobsConnectionTypeConnection,
        graphql_name="getEtlJobsV2",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("resource_uuid", sgqlc.types.Arg(UUID, graphql_name="resourceUuid", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "with_recent_runs",
                    sgqlc.types.Arg(Boolean, graphql_name="withRecentRuns", default=False),
                ),
                (
                    "no_recent_runs",
                    sgqlc.types.Arg(Boolean, graphql_name="noRecentRuns", default=False),
                ),
                ("job_name", sgqlc.types.Arg(String, graphql_name="jobName", default=None)),
                (
                    "order_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="orderBy", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get ETL Jobs

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `resource_uuid` (`UUID`): Filter by ETL container
    * `mcons` (`[String]`): Filter by mcons
    * `with_recent_runs` (`Boolean`): Filter to Jobs that have had
      runs within the last 30 days (default: `false`)
    * `no_recent_runs` (`Boolean`): Filter to Jobs that have not had
      runs within the last 30 days (default: `false`)
    * `job_name` (`String`): Filter by job name
    * `order_by` (`[String]`): List of order by fields ie
      '["-jobName", "generatesIncidents"]'
    """

    get_etl_tasks = sgqlc.types.Field(
        ETLTasksType,
        graphql_name="getEtlTasks",
        args=sgqlc.types.ArgDict(
            (
                (
                    "first",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="first", default=None),
                ),
                (
                    "offset",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="offset", default=None),
                ),
                (
                    "job_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobMcons", default=None
                    ),
                ),
                (
                    "task_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="taskMcons", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get ETL tasks for the given set of ETL Jobs or
    specific tasks by mcons

    Arguments:

    * `first` (`Int!`): Page size
    * `offset` (`Int!`): Page offset
    * `job_mcons` (`[String]`): Filter by job mcons
    * `task_mcons` (`[String]`): Filter by task mcons
    """

    search_etl_jobs_and_tasks = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ETLJobOrTaskSearchResult)),
        graphql_name="searchEtlJobsAndTasks",
        args=sgqlc.types.ArgDict(
            (
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="search", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=50)),
            )
        ),
    )
    """(experimental) Search for ETL jobs and tasks by name across all
    types

    Arguments:

    * `search` (`String!`): Search string to filter by name
    * `limit` (`Int`): Maximum results to return (default: `50`)
    """

    get_data_product = sgqlc.types.Field(
        "DataProduct",
        graphql_name="getDataProduct",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_product_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dataProductId", default=None
                    ),
                ),
                (
                    "upstream_levels",
                    sgqlc.types.Arg(Int, graphql_name="upstreamLevels", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Get a data product

    Arguments:

    * `data_product_id` (`UUID!`): Data product id
    * `upstream_levels` (`Int`): Number of upstream levels used to
      calculate upstream dependencies
    * `domain_id` (`UUID`): Filter assets by domain UUID
    """

    get_data_product_v2 = sgqlc.types.Field(
        "DataProduct",
        graphql_name="getDataProductV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_product_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dataProductId", default=None
                    ),
                ),
                (
                    "upstream_levels",
                    sgqlc.types.Arg(Int, graphql_name="upstreamLevels", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Get a data product

    Arguments:

    * `data_product_id` (`UUID!`): Data product id
    * `upstream_levels` (`Int`): Number of upstream levels used to
      calculate upstream dependencies
    * `domain_id` (`UUID`): Filter assets by domain UUID
    """

    get_data_products = sgqlc.types.Field(
        sgqlc.types.list_of("DataProduct"),
        graphql_name="getDataProducts",
        args=sgqlc.types.ArgDict(
            (("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),)
        ),
    )
    """Get a list of data products

    Arguments:

    * `domain_id` (`UUID`): Filter assets by domain UUID
    """

    get_data_products_v2 = sgqlc.types.Field(
        sgqlc.types.list_of("DataProduct"),
        graphql_name="getDataProductsV2",
        args=sgqlc.types.ArgDict(
            (
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
            )
        ),
    )
    """Get a list of data products

    Arguments:

    * `domain_id` (`UUID`): Filter assets by domain UUID. Deprecated,
      kept for backwards compatibility. Please use domain_ids field.
    * `domain_ids` (`[UUID]`): Filter assets by domain UUIDs.
    """

    get_domain_filtered_data_products = sgqlc.types.Field(
        sgqlc.types.list_of("DataProduct"),
        graphql_name="getDomainFilteredDataProducts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Get a list of data products filtered by
    domain

    Arguments:

    * `domain_ids` (`[UUID]`): Filter data products by domain UUID/s.
    """

    get_data_product_metrics = sgqlc.types.Field(
        sgqlc.types.list_of(DataProductMetricData),
        graphql_name="getDataProductMetrics",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_product_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dataProductId", default=None
                    ),
                ),
                (
                    "metrics",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(DataProductMetric)),
                        graphql_name="metrics",
                        default=None,
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "incident_categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="incidentCategories",
                        default=None,
                    ),
                ),
                (
                    "upstream_levels",
                    sgqlc.types.Arg(Int, graphql_name="upstreamLevels", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Get one or more data product metric values

    Arguments:

    * `data_product_id` (`UUID!`): Data product id
    * `metrics` (`[DataProductMetric]!`): Metrics to calculate
    * `start_time` (`DateTime!`): Filter incidents newer than this
    * `end_time` (`DateTime`): Filter incidents older than this
    * `timezone` (`String`): Timezone to apply when grouping by date
    * `include_feedback` (`[String]`): Filter incidents by user
      feedback
    * `exclude_feedback` (`[String]`): Exclude incidents by user
      feedback
    * `include_normalized` (`Boolean`): If false, filter out
      normalized incidents.
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `incident_categories` (`[IncidentCategory]`): Include only
      selected incident categories. Or all categories if not
      specified.
    * `upstream_levels` (`Int`): Number of upstream levels used to
      calculate upstream dependencies
    * `domain_id` (`UUID`): Filter assets by domain UUID
    """

    get_data_product_metrics_v2 = sgqlc.types.Field(
        sgqlc.types.list_of(DataProductMetricData),
        graphql_name="getDataProductMetricsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_product_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dataProductId", default=None
                    ),
                ),
                (
                    "metrics",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(DataProductMetric)),
                        graphql_name="metrics",
                        default=None,
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "incident_categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="incidentCategories",
                        default=None,
                    ),
                ),
                (
                    "upstream_levels",
                    sgqlc.types.Arg(Int, graphql_name="upstreamLevels", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Get one or more data product metric values

    Arguments:

    * `data_product_id` (`UUID!`): Data product id
    * `metrics` (`[DataProductMetric]!`): Metrics to calculate
    * `start_time` (`DateTime!`): Filter incidents newer than this
    * `end_time` (`DateTime`): Filter incidents older than this
    * `timezone` (`String`): Timezone to apply when grouping by date
    * `include_feedback` (`[String]`): Filter incidents by user
      feedback
    * `exclude_feedback` (`[String]`): Exclude incidents by user
      feedback
    * `include_normalized` (`Boolean`): If false, filter out
      normalized incidents.
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `incident_categories` (`[IncidentCategory]`): Include only
      selected incident categories. Or all categories if not
      specified.
    * `upstream_levels` (`Int`): Number of upstream levels used to
      calculate upstream dependencies
    * `domain_id` (`UUID`): Filter assets by domain UUID
    """

    get_data_product_asset_data = sgqlc.types.Field(
        DataProductAssetData,
        graphql_name="getDataProductAssetData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Fetches data about an asset's status vis a vis data products

    Arguments:

    * `mcon` (`String!`): The mcon to fetch data for
    """

    get_data_product_upstream_counts = sgqlc.types.Field(
        DataProductUpstreamCoverageData,
        graphql_name="getDataProductUpstreamCounts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """(general availability) Fetch data about table upstream status as
    well as total counts

    Arguments:

    * `mcons` (`[String]!`): List of table MCONS to filter the result
    * `domain_id` (`UUID`): Filter by domain UUID
    """

    get_data_product_audiences = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(NotificationAudience)),
        graphql_name="getDataProductAudiences",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_product_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="dataProductUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) List of audiences for this product id

    Arguments:

    * `data_product_uuid` (`UUID!`): Data product UUID
    """

    get_top_warehouse_for_data_product_mcons = sgqlc.types.Field(
        UUID,
        graphql_name="getTopWarehouseForDataProductMcons",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get the warehouse UUID with the most associated
    MCONs

    Arguments:

    * `mcons` (`[String]!`): List of MCONs to analyze
    """

    get_data_product_dry_run_counts = sgqlc.types.Field(
        DataProductDryRunTableCounts,
        graphql_name="getDataProductDryRunCounts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Return asset counts for a data product had it been
    created from these MCONs

    Arguments:

    * `mcons` (`[String]!`): MCON of assets to create data product
      from
    """

    parse_query = sgqlc.types.Field(
        "SqlParserResult",
        graphql_name="parseQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="query", default=None
                    ),
                ),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("database", sgqlc.types.Arg(String, graphql_name="database", default=None)),
                ("schema", sgqlc.types.Arg(String, graphql_name="schema", default=None)),
            )
        ),
    )
    """Arguments:

    * `query` (`String!`): SQL query to parse
    * `resource_id` (`UUID`): Id of resource/warehouse to use for
      table resolution
    * `database` (`String`): Name of database to use for table
      resolution
    * `schema` (`String`): Name of schema to use for table resolution
    """

    ping_data_collector = sgqlc.types.Field(
        DcPingResponse,
        graphql_name="pingDataCollector",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dc_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dcId", default=None),
                ),
                (
                    "trace_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="traceId", default=None
                    ),
                ),
            )
        ),
    )
    """Sends a ping request to a data collector to verify it is
    operational.

    Arguments:

    * `dc_id` (`UUID!`): The UUID identifying the data collector to
      ping.
    * `trace_id` (`UUID!`): A unique identifier for correlating the
      data collector ping.
    """

    get_ms_teams_integrations = sgqlc.types.Field(
        MsTeamsInstallationList, graphql_name="getMsTeamsIntegrations"
    )

    get_ms_teams_channels = sgqlc.types.Field(
        MsTeamsChannelList,
        graphql_name="getMsTeamsChannels",
        args=sgqlc.types.ArgDict(
            (
                ("team_id", sgqlc.types.Arg(String, graphql_name="teamId", default=None)),
                (
                    "name_contains",
                    sgqlc.types.Arg(String, graphql_name="nameContains", default=None),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=100)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
            )
        ),
    )
    """Arguments:

    * `team_id` (`String`)None
    * `name_contains` (`String`)None
    * `limit` (`Int`)None (default: `100`)
    * `offset` (`Int`)None (default: `0`)
    """

    get_github_integrations = sgqlc.types.Field(GithubAppInfo, graphql_name="getGithubIntegrations")
    """Github integration info"""

    get_gitlab_integrations = sgqlc.types.Field(GitlabAppInfo, graphql_name="getGitlabIntegrations")
    """(experimental) Gitlab integration info"""

    get_gitlab_integration = sgqlc.types.Field(
        GitlabAppInstallation,
        graphql_name="getGitlabIntegration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="installationUuid", default=None),
                ),
            )
        ),
    )
    """(experimental) Gitlab integration info

    Arguments:

    * `installation_uuid` (`UUID`)None
    """

    get_github_pull_requests = sgqlc.types.Field(
        GithubPullRequestsList,
        graphql_name="getGithubPullRequests",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentUuid", default=None
                    ),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "include_zero_score",
                    sgqlc.types.Arg(Boolean, graphql_name="includeZeroScore", default=False),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=10)),
            )
        ),
    )
    """Get the list of pull requests related to a given incident

    Arguments:

    * `incident_uuid` (`UUID!`): Incident UUID to get PRs for
    * `mcon` (`String`): mcon of the table to get the PRs for
    * `include_zero_score` (`Boolean`): Include PRs with 0 relevance
      score (default: `false`)
    * `limit` (`Int`): Limit the number of PRs returned (default:
      `10`)
    """

    traverse_gitlab_projects = sgqlc.types.Field(
        GitlabTraversalResult,
        graphql_name="traverseGitlabProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
                ("parent_id", sgqlc.types.Arg(Int, graphql_name="parentId", default=None)),
            )
        ),
    )
    """(experimental) List groups and projects in Gitlab integration

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the installation
    * `parent_id` (`Int`): Gitlab ID of the parent group
    """

    get_github_pull_requests_for_table = sgqlc.types.Field(
        GithubPullRequestsList,
        graphql_name="getGithubPullRequestsForTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "include_zero_score",
                    sgqlc.types.Arg(Boolean, graphql_name="includeZeroScore", default=False),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=10)),
            )
        ),
    )
    """Get the list of pull requests related to a given incident.
    DEPRECATED: Use getGithubPullRequestsForTableV2

    Arguments:

    * `mcon` (`String!`): mcon of the table to get the PRs for
    * `include_zero_score` (`Boolean`): Include PRs with 0 relevance
      score (default: `false`)
    * `limit` (`Int`): Limit the number of PRs returned (default:
      `10`)
    """

    get_github_pull_requests_for_table_v2 = sgqlc.types.Field(
        GithubPullRequestConnection,
        graphql_name="getGithubPullRequestsForTableV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get the list of pull requests related to a given incident

    Arguments:

    * `mcon` (`String!`): mcon of the table to get the PRs for
    * `start_time` (`DateTime`): Get PRs merged after this time
    * `end_time` (`DateTime`): Get PRs merged at or before this time
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_vcs_summary = sgqlc.types.Field(
        "VCSSummary",
        graphql_name="getVcsSummary",
        args=sgqlc.types.ArgDict(
            (
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(PullRequestFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Returns summary of pull requests available

    Arguments:

    * `start_time` (`DateTime!`): Get PRs merged after this time
    * `end_time` (`DateTime!`): Get PRs merged at or before this time
    * `filters` (`[PullRequestFilterInput]`): Filters to apply to the
      list
    """

    get_vcs_pull_requests = sgqlc.types.Field(
        GithubPullRequestConnection,
        graphql_name="getVcsPullRequests",
        args=sgqlc.types.ArgDict(
            (
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(PullRequestFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """(experimental) Get the list of pull requests

    Arguments:

    * `start_time` (`DateTime!`): Get PRs merged after this time
    * `end_time` (`DateTime!`): Get PRs merged at or before this time
    * `filters` (`[PullRequestFilterInput]`): Filters to apply to the
      list
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `order_by` (`String`): Order results by `mergedAt`
    """

    get_gitlab_projects = sgqlc.types.Field(
        sgqlc.types.list_of(GitlabNamespace),
        graphql_name="getGitlabProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get GitLab projects for the current user

    Arguments:

    * `installation_uuid` (`UUID!`): Internal UUID of the GitLab
      installation
    """

    get_azure_devops_installations = sgqlc.types.Field(
        AzureDevopsInstallations, graphql_name="getAzureDevopsInstallations"
    )
    """(experimental) Azure DevOps installations"""

    get_azure_devops_installation = sgqlc.types.Field(
        AzureDevopsInstallation,
        graphql_name="getAzureDevopsInstallation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Azure DevOps installations

    Arguments:

    * `installation_uuid` (`UUID!`)None
    """

    get_azure_devops_organization = sgqlc.types.Field(
        AzureDevopsOrganization,
        graphql_name="getAzureDevopsOrganization",
        args=sgqlc.types.ArgDict(
            (
                (
                    "installation_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="installationUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Azure DevOps organization

    Arguments:

    * `installation_uuid` (`UUID!`): Installation UUID to get Azure
      DevOps Organization for
    """

    get_size_collection_configuration = sgqlc.types.Field(
        "SizeCollectionConfiguration",
        graphql_name="getSizeCollectionConfiguration",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """Size Collection configuration for an assets with size collection

    Arguments:

    * `mcon` (`String`): MC unique identifier of the object
    """

    get_size_collection_query = sgqlc.types.Field(
        "SizeCollectionQuery",
        graphql_name="getSizeCollectionQuery",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """Retrieve query executed by size collection for the given asset

    Arguments:

    * `mcon` (`String`): MC unique identifier of the object
    * `where_condition` (`String`): Where condition to include with
      collection query
    """

    get_my_mcp_integration_keys = sgqlc.types.Field(
        sgqlc.types.list_of(IntegrationKeyMetadata),
        graphql_name="getMyMcpIntegrationKeys",
        args=sgqlc.types.ArgDict(
            (
                (
                    "include_created_by_service_accounts",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="includeCreatedByServiceAccounts", default=True
                    ),
                ),
            )
        ),
    )
    """(experimental) Retrieve MCP integration keys created by the
    current user

    Arguments:

    * `include_created_by_service_accounts` (`Boolean`): Whether to
      include the MCP keys created by service accounts (default:
      `true`)
    """

    get_opsgenie_integrations = sgqlc.types.Field(
        sgqlc.types.list_of(OpsgenieIntegrationOutput),
        graphql_name="getOpsgenieIntegrations",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None),
                ),
                ("webhook_id", sgqlc.types.Arg(UUID, graphql_name="webhookId", default=None)),
            )
        ),
    )
    """(experimental) Get Opsgenie integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    * `webhook_id` (`UUID`): Filter by webhook ID
    """

    get_pagerduty_service_integrations = sgqlc.types.Field(
        sgqlc.types.list_of(PagerDutyServiceIntegrationOutput),
        graphql_name="getPagerdutyServiceIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """Get the configured PagerDuty service integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    get_volume_change_table_monitor = sgqlc.types.Field(
        "VolumeChangeTableMonitorConfigOutput",
        graphql_name="getVolumeChangeTableMonitor",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """(experimental) Get volume change table monitor configuration for
    an asset

    Arguments:

    * `mcon` (`String`): MC unique identifier of the object
    """

    get_ucs_table_monitor = sgqlc.types.Field(
        "UCSTableMonitorConfigOutput",
        graphql_name="getUcsTableMonitor",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """(experimental) Get ucs table monitor configuration for an asset

    Arguments:

    * `mcon` (`String`): MC unique identifier of the object
    """

    migrate_to_table_monitors = sgqlc.types.Field(
        ConversionResult,
        graphql_name="migrateToTableMonitors",
        args=sgqlc.types.ArgDict(
            (
                ("load_path", sgqlc.types.Arg(String, graphql_name="loadPath", default=None)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=True)),
                ("coverage", sgqlc.types.Arg(Boolean, graphql_name="coverage", default=False)),
            )
        ),
    )
    """(experimental) Migrate notification routing rules and monitoring
    rules to table monitors.

    Arguments:

    * `load_path` (`String`): Load migration data from a previously
      created dump instead of querying the database. Pass empty string
      to use default location based on user's account. Only available
      during unit tests.
    * `dry_run` (`Boolean`): Only analyze and show what would be
      created without actually creating table monitors (default:
      True). Non-dry-run migrations require system user
      authentication. (default: `true`)
    * `coverage` (`Boolean`): Calculate expensive coverage statistics
      such as distinct tables covered and top MCONs by monitor count
      (default: False). (default: `false`)
    """

    get_freshness_table_monitor = sgqlc.types.Field(
        FreshnessTableMonitorConfigOutput,
        graphql_name="getFreshnessTableMonitor",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """(experimental) Get freshness table monitor configuration for an
    asset

    Arguments:

    * `mcon` (`String`): MC unique identifier of the object
    """

    get_slack_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("SlackUserOutput")),
        graphql_name="getSlackUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "team_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="teamId", default=None
                    ),
                ),
                (
                    "user_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
                        graphql_name="userIds",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Bulk fetch Slack users by IDs

    Arguments:

    * `team_id` (`String!`): Slack team/workspace ID
    * `user_ids` (`[String!]!`): List of Slack user IDs to fetch
    """

    get_slack_user_groups = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("SlackUserGroupOutput")),
        graphql_name="getSlackUserGroups",
        args=sgqlc.types.ArgDict(
            (
                (
                    "team_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="teamId", default=None
                    ),
                ),
                (
                    "usergroup_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
                        graphql_name="usergroupIds",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Bulk fetch Slack user groups by IDs

    Arguments:

    * `team_id` (`String!`): Slack team/workspace ID
    * `usergroup_ids` (`[String!]!`): List of Slack user group IDs to
      fetch
    """

    list_slack_users = sgqlc.types.Field(
        "SlackUserListOutput",
        graphql_name="listSlackUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "team_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="teamId", default=None
                    ),
                ),
                ("cursor", sgqlc.types.Arg(String, graphql_name="cursor", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """(experimental) List Slack users with pagination (pass-through to
    Slack API). Returns only id and display_name for efficiency.
    Clients can do their own filtering.

    Arguments:

    * `team_id` (`String!`): Slack team/workspace ID
    * `cursor` (`String`): Pagination cursor from previous response
    * `limit` (`Int`): Number of results per page (default 1000, max
      1000)
    """

    list_slack_user_groups = sgqlc.types.Field(
        "SlackUserGroupListOutput",
        graphql_name="listSlackUserGroups",
        args=sgqlc.types.ArgDict(
            (
                (
                    "team_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="teamId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) List all Slack user groups (pass-through to Slack
    API). Returns only id and name for efficiency. Clients can do
    their own filtering. Note: Slack's API does not support pagination
    for user groups.

    Arguments:

    * `team_id` (`String!`): Slack team/workspace ID
    """

    get_servicenow_incident_fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("ServiceNowFieldOutput")),
        graphql_name="getServicenowIncidentFields",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "mandatory_only",
                    sgqlc.types.Arg(Boolean, graphql_name="mandatoryOnly", default=None),
                ),
            )
        ),
    )
    """(experimental) Get ServiceNow incident fields

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `mandatory_only` (`Boolean`): If true, return only mandatory
      fields
    """

    get_servicenow_users = sgqlc.types.Field(
        sgqlc.types.list_of("ServiceNowUserOutput"),
        graphql_name="getServicenowUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
            )
        ),
    )
    """(experimental) Get the list of ServiceNow users

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `query` (`String`): A query to filter users by name
    """

    get_servicenow_integrations = sgqlc.types.Field(
        sgqlc.types.list_of("ServiceNowIntegrationOutput"),
        graphql_name="getServicenowIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """(experimental) Get the configured ServiceNow integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    get_servicenow_reference_values = sgqlc.types.Field(
        sgqlc.types.list_of("ServiceNowChoiceOutput"),
        graphql_name="getServicenowReferenceValues",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "field_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="fieldName", default=None
                    ),
                ),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """(experimental) Get possible values for an incident field when the
    field is a reference type. Pass the field name and an optional
    query to filter by label.

    Arguments:

    * `integration_id` (`UUID!`): The integration ID
    * `field_name` (`String!`): Incident field name of the reference
    * `query` (`String`): Optional filter for label
    * `limit` (`Int`): Optional limit (default 100)
    """

    test_servicenow_credentials = sgqlc.types.Field(
        "ServiceNowTestCredentialsOutput",
        graphql_name="testServicenowCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "instance_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="instanceName", default=None
                    ),
                ),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
                (
                    "credentials",
                    sgqlc.types.Arg(
                        ServiceNowCredentialsUnionInput, graphql_name="credentials", default=None
                    ),
                ),
                (
                    "options",
                    sgqlc.types.Arg(
                        ServiceNowIntegrationOptionsInput, graphql_name="options", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Test the ServiceNow connection credentials

    Arguments:

    * `instance_name` (`String!`): The instance name of the ServiceNow
      site
    * `username` (`String`): The ServiceNow username for basic
      authentication. DEPRECATED: Use credentials instead.
    * `password` (`String`): The user's password for basic
      authentication. DEPRECATED: Use credentials instead.
    * `credentials` (`ServiceNowCredentialsUnionInput`): The
      ServiceNow credentials
    * `options` (`ServiceNowIntegrationOptionsInput`): Options for
      ServiceNow integration
    """

    test_azure_devops_credentials = sgqlc.types.Field(
        "TestAzureDevOpsCredentialsOutput",
        graphql_name="testAzureDevopsCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "organization",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="organization", default=None
                    ),
                ),
                (
                    "basic_auth_credentials",
                    sgqlc.types.Arg(
                        AzureDevOpsBasicAuthCredentialsInput,
                        graphql_name="basicAuthCredentials",
                        default=None,
                    ),
                ),
                (
                    "oauth_credentials",
                    sgqlc.types.Arg(
                        AzureDevOpsOauthCredentialsInput,
                        graphql_name="oauthCredentials",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Test the Azure DevOps connection credentials

    Arguments:

    * `organization` (`String!`): Azure DevOps organization name
    * `basic_auth_credentials`
      (`AzureDevOpsBasicAuthCredentialsInput`): Basic auth credentials
      to test (PAT)
    * `oauth_credentials` (`AzureDevOpsOauthCredentialsInput`): OAuth
      credentials to test (not yet supported for testing)
    """

    get_azure_devops_integrations = sgqlc.types.Field(
        sgqlc.types.list_of(AzureDevOpsIntegrationOutput),
        graphql_name="getAzureDevopsIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """(experimental) Get Azure DevOps work item integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    get_azure_devops_projects = sgqlc.types.Field(
        sgqlc.types.list_of(AzureDevOpsProjectOutput),
        graphql_name="getAzureDevopsProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get list of projects for an Azure DevOps
    integration

    Arguments:

    * `integration_id` (`UUID!`): ID of the Azure DevOps integration
    """

    get_azure_devops_work_item_types = sgqlc.types.Field(
        sgqlc.types.list_of(AzureDevOpsWorkItemTypeOutput),
        graphql_name="getAzureDevopsWorkItemTypes",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "project",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="project", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get list of work item types for a project

    Arguments:

    * `integration_id` (`UUID!`): ID of the Azure DevOps integration
    * `project` (`String!`): Project name
    """

    get_jira_integrations = sgqlc.types.Field(
        sgqlc.types.list_of(JiraIntegrationOutput),
        graphql_name="getJiraIntegrations",
        args=sgqlc.types.ArgDict(
            (("integration_id", sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None)),)
        ),
    )
    """Get the configured Jira integrations

    Arguments:

    * `integration_id` (`UUID`): Filter by integration ID
    """

    search_jira_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraUserOutput)),
        graphql_name="searchJiraUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "project",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="project", default=None
                    ),
                ),
                (
                    "query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="query", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Search for Jira users

    Arguments:

    * `integration_id` (`UUID!`): Jira integration ID
    * `project` (`Int!`): Jira project ID
    * `query` (`String!`): The search query
    """

    get_jira_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraUserOutput)),
        graphql_name="getJiraUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                (
                    "keys",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="keys",
                        default=None,
                    ),
                ),
                (
                    "account_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="accountIds",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Bulk get Jira users by identifiers

    Arguments:

    * `integration_id` (`UUID!`): Jira integration ID
    * `keys` (`[String!]`): Jira user keys (For Jira Data Center)
    * `account_ids` (`[String!]`): Jira user accountIds (For Jira
      Cloud)
    """

    get_jira_statuses = sgqlc.types.Field(
        sgqlc.types.list_of(JiraStatusOutput),
        graphql_name="getJiraStatuses",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(UUID, graphql_name="integrationId", default=None),
                ),
                ("server_url", sgqlc.types.Arg(String, graphql_name="serverUrl", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                ("api_token", sgqlc.types.Arg(String, graphql_name="apiToken", default=None)),
            )
        ),
    )
    """Get Jira statuses for the given integration or set of credentials

    Arguments:

    * `integration_id` (`UUID`): Jira integration id
    * `server_url` (`String`): The domain name for your Jira site
    * `username` (`String`): The Jira username for basic
      authentication
    * `api_token` (`String`): The personal API token for basic
      authentication
    """

    get_jira_teams = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraTeamOutput)),
        graphql_name="getJiraTeams",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """Get Jira teams for the given integration

    Arguments:

    * `integration_id` (`UUID!`): Jira integration id
    """

    get_jira_projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraProjectOutput)),
        graphql_name="getJiraProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
            )
        ),
    )
    """Get Jira projects for the given integration

    Arguments:

    * `integration_id` (`UUID!`): Jira integration id
    """

    get_jira_issue_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JiraIssueTypeOutput)),
        graphql_name="getJiraIssueTypes",
        args=sgqlc.types.ArgDict(
            (
                (
                    "integration_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="integrationId", default=None
                    ),
                ),
                ("project", sgqlc.types.Arg(Int, graphql_name="project", default=None)),
                (
                    "required_fields_only",
                    sgqlc.types.Arg(Boolean, graphql_name="requiredFieldsOnly", default=False),
                ),
            )
        ),
    )
    """Get Jira issue types for the integration

    Arguments:

    * `integration_id` (`UUID!`): Jira integration ID
    * `project` (`Int`): Filter by Jira project ID
    * `required_fields_only` (`Boolean`): Filter fields to only those
      which are required (default: `false`)
    """

    test_jira_credentials = sgqlc.types.Field(
        JiraTestCredentialsOutput,
        graphql_name="testJiraCredentials",
        args=sgqlc.types.ArgDict(
            (
                (
                    "server_url",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="serverUrl", default=None
                    ),
                ),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                (
                    "api_token",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="apiToken", default=None
                    ),
                ),
                (
                    "is_token_auth",
                    sgqlc.types.Arg(Boolean, graphql_name="isTokenAuth", default=False),
                ),
            )
        ),
    )
    """Test the Jira connection credentials

    Arguments:

    * `server_url` (`String!`): The domain name for your Jira site
    * `username` (`String`): The Jira username for basic
      authentication
    * `api_token` (`String!`): The personal API token for basic
      authentication or token authentication
    * `is_token_auth` (`Boolean`): Whether the integration is using
      Token Auth. Defaults to Basic Auth (default: `false`)
    """

    get_jobs_performance_data = sgqlc.types.Field(
        JobPerformanceData,
        graphql_name="getJobsPerformanceData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JobsPerformanceFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
                (
                    "paging",
                    sgqlc.types.Arg(
                        JobsPerformancePagingInput, graphql_name="paging", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get jobs performance data

    Arguments:

    * `filters` (`JobsPerformanceFilterInput!`): Filters to apply
    * `paging` (`JobsPerformancePagingInput`): Paging parameters
    """

    get_jobs_performance_facets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(JobsPerformanceFacetResponse)),
        graphql_name="getJobsPerformanceFacets",
        args=sgqlc.types.ArgDict(
            (
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JobsPerformanceFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
                ("options_limit", sgqlc.types.Arg(Int, graphql_name="optionsLimit", default=None)),
            )
        ),
    )
    """(experimental) Get facet data for jobs that match the filters

    Arguments:

    * `filters` (`JobsPerformanceFilterInput!`): Current filters being
      applied to the job performance result set
    * `options_limit` (`Int`): Maximum number of options to return.
      Defaults to 100
    """

    search_jobs_performance_facet = sgqlc.types.Field(
        sgqlc.types.non_null(JobsPerformanceFacetResponse),
        graphql_name="searchJobsPerformanceFacet",
        args=sgqlc.types.ArgDict(
            (
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JobsPerformanceFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
                (
                    "facet",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(JobsPerformanceFacetQueryInput),
                        graphql_name="facet",
                        default=None,
                    ),
                ),
                ("options_limit", sgqlc.types.Arg(Int, graphql_name="optionsLimit", default=None)),
            )
        ),
    )
    """(experimental) Search options within a single facet of jobs
    performance data

    Arguments:

    * `filters` (`JobsPerformanceFilterInput!`): Current filters being
      applied to the job performance result set
    * `facet` (`JobsPerformanceFacetQueryInput!`): Indicate the facet
      to search in and the search text
    * `options_limit` (`Int`): Maximum number of options to return.
      Defaults to 100
    """

    get_tasks_performance_data = sgqlc.types.Field(
        "TaskPerformanceData",
        graphql_name="getTasksPerformanceData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TasksPerformanceFilterInput),
                        graphql_name="filters",
                        default=None,
                    ),
                ),
                (
                    "paging",
                    sgqlc.types.Arg(
                        TasksPerformancePagingInput, graphql_name="paging", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get tasks performance data

    Arguments:

    * `filters` (`TasksPerformanceFilterInput!`): Filters to apply
    * `paging` (`TasksPerformancePagingInput`): Paging parameters
    """

    get_query_perf_rule_execution_history_logs = sgqlc.types.Field(
        sgqlc.types.list_of(JobExecutionHistoryLog),
        graphql_name="getQueryPerfRuleExecutionHistoryLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "rule_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="ruleUuid", default=None
                    ),
                ),
                ("history_days", sgqlc.types.Arg(Int, graphql_name="historyDays", default=7)),
            )
        ),
    )
    """Arguments:

    * `rule_uuid` (`UUID!`): UUID of the Query Performance
      Monitor/Rule
    * `history_days` (`Int`): Number of lookback days (default: `7`)
    """

    simulate_query_perf_monitor_evaluation = sgqlc.types.Field(
        QPMonitorSimulationType,
        graphql_name="simulateQueryPerfMonitorEvaluation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SimulateMonitorEvaluationRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
                (
                    "config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QPMonitorConfigInputType),
                        graphql_name="config",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`SimulateMonitorEvaluationRequestType!`)None
    * `config` (`QPMonitorConfigInputType!`): Monitor configuration
    """

    get_query_perf_monitor_explanation_for_event = sgqlc.types.Field(
        QPMonitorExplanationType,
        graphql_name="getQueryPerfMonitorExplanationForEvent",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GetExplanationForEventRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`GetExplanationForEventRequestType!`)None
    """

    get_query_perf_monitor_explanation = sgqlc.types.Field(
        QPMonitorExplanationType,
        graphql_name="getQueryPerfMonitorExplanation",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(GetExplanationRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
                (
                    "config",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QPMonitorConfigInputType),
                        graphql_name="config",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`GetExplanationRequestType!`)None
    * `config` (`QPMonitorConfigInputType!`): QP monitor config
    """

    get_indexed_field_specs = sgqlc.types.Field(
        sgqlc.types.list_of(IndexedFieldSpecType),
        graphql_name="getIndexedFieldSpecs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "included_facets_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(DashboardType),
                        graphql_name="includedFacetsTypes",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `included_facets_types` (`[DashboardType]`): Facet types to
      include in the results. Can be READ, WRITE or both. By default
      it will use WRITE
    """

    get_query_logs = sgqlc.types.Field(
        "QueryLogsResponseType",
        graphql_name="getQueryLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryLogsRequestInput),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`QueryLogsRequestInput!`)None
    """

    get_query_log_timeline = sgqlc.types.Field(
        "QueryLogTimeline",
        graphql_name="getQueryLogTimeline",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryLogsRequestInput),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Retrieve optimized minimal timeline of queries

    Arguments:

    * `request` (`QueryLogsRequestInput!`)None
    """

    get_query_logs_facets_v2 = sgqlc.types.Field(
        sgqlc.types.list_of("QueryLogsFacetResponseType"),
        graphql_name="getQueryLogsFacetsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryLogsFacetRequestTypeV2),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`QueryLogsFacetRequestTypeV2!`)None
    """

    get_query_logs_facets = sgqlc.types.Field(
        "QueryLogsFacetResponseType",
        graphql_name="getQueryLogsFacets",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryLogsFacetRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`QueryLogsFacetRequestType!`)None
    """

    get_query_runtime_percentile_timeseries = sgqlc.types.Field(
        "QueryRuntimePercentileTimeSeriesResponseType",
        graphql_name="getQueryRuntimePercentileTimeseries",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryRuntimePercentileTimeSeriesRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Returns data for the Latency Distribution Line Graph for read
    queries

    Arguments:

    * `request` (`QueryRuntimePercentileTimeSeriesRequestType!`)None
    """

    get_query_performance_data = sgqlc.types.Field(
        sgqlc.types.list_of(AggregatedMetricDataType),
        graphql_name="getQueryPerformanceData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryPerformanceDataRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get aggregated query performance data

    Arguments:

    * `request` (`QueryPerformanceDataRequestType!`)None
    """

    get_top_query_groups = sgqlc.types.Field(
        "TopQueryGroupsResponseType",
        graphql_name="getTopQueryGroups",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(TopQueryGroupsRequestType),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `request` (`TopQueryGroupsRequestType!`)None
    """

    get_aggregated_queries = sgqlc.types.Field(
        AggregatedQueryResults,
        graphql_name="getAggregatedQueries",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "query_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryType), graphql_name="queryType", default=None
                    ),
                ),
                (
                    "limit",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="limit", default=None),
                ),
                ("end_cursor", sgqlc.types.Arg(String, graphql_name="endCursor", default=None)),
                ("category", sgqlc.types.Arg(QueryCategory, graphql_name="category", default=None)),
                ("user", sgqlc.types.Arg(String, graphql_name="user", default=None)),
                (
                    "query_characters",
                    sgqlc.types.Arg(Int, graphql_name="queryCharacters", default=50),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Retrieve aggregated metrics

    Arguments:

    * `mcon` (`String!`): MCON for the table
    * `start_time` (`DateTime!`): Filter for queries on or after this
      date
    * `end_time` (`DateTime!`): Filter for queries on or before this
      date
    * `query_type` (`QueryType!`): Filter for reads or writes to the
      table
    * `limit` (`Int!`): Number of aggregated queries to return. Up to
      a maximum of 1000
    * `end_cursor` (`String`): Cursor used to get results from the
      next page
    * `category` (`QueryCategory`): Filter queries by category
    * `user` (`String`): Filter queries by user
    * `query_characters` (`Int`): Number of characters to return for
      the sample query (default: `50`)
    """

    get_query_rcas = sgqlc.types.Field(
        sgqlc.types.list_of("QueryRca"),
        graphql_name="getQueryRcas",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
            )
        ),
    )
    """Get query RCAs for a given incident.

    Arguments:

    * `incident_id` (`UUID`): Incident identifier. Deprecated, use
      alertId instead
    * `alert_id` (`UUID`): Alert identifier
    """

    get_query_dimensions = sgqlc.types.Field(
        "QueryDimensions",
        graphql_name="getQueryDimensions",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "query_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(QueryType), graphql_name="queryType", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `mcon` (`String!`): Mcon for table to get query dimensions for
    * `start_time` (`DateTime!`): Filter for queries on or after this
      date
    * `end_time` (`DateTime!`): Filter for queries on or before this
      date
    * `query_type` (`QueryType!`): Filter for reads or writes to the
      table
    """

    get_query_text = sgqlc.types.Field(
        String,
        graphql_name="getQueryText",
        args=sgqlc.types.ArgDict(
            (
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `key` (`String!`): Query text key
    """

    get_queried_tables = sgqlc.types.Field(
        sgqlc.types.list_of(QueriedTable),
        graphql_name="getQueriedTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "limit",
                    sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="limit", default=None),
                ),
                ("user", sgqlc.types.Arg(String, graphql_name="user", default=None)),
            )
        ),
    )
    """(experimental) List of tables queried by a given user

    Arguments:

    * `start_time` (`DateTime!`): Start of the period to consider
    * `end_time` (`DateTime!`): End of the period to consider
    * `limit` (`Int!`): Number of tables to return.
    * `user` (`String`): Filter queries by user (email)
    """

    get_notification_settings = sgqlc.types.Field(
        sgqlc.types.list_of(AccountNotificationSetting),
        graphql_name="getNotificationSettings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="monitorLabels", default=None
                    ),
                ),
            )
        ),
    )
    """Get notification settings

    Arguments:

    * `monitor_labels` (`[String]`): Filter by notifications that
      handle these monitor labels
    """

    get_notification_audiences = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(NotificationAudience)),
        graphql_name="getNotificationAudiences",
        args=sgqlc.types.ArgDict(
            (
                ("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="createdBy", default=None
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) Get notification audiences

    Arguments:

    * `audience_id` (`UUID`): Audience associated with the recipient
    * `search` (`String`): Search text to filter the audiences list,
      returning those whose labels contain the specified text
    * `created_by` (`[String]`): Filter by creator using a list of
      user emails. It can include null to filter audiences without a
      creator
    * `order_by` (`String`): Field and direction to order audiences by
    * `limit` (`Int`): Number of audiences to return
    * `offset` (`Int`): From which audience to return the next results
    """

    get_notification_audiences_count = sgqlc.types.Field(
        Int,
        graphql_name="getNotificationAudiencesCount",
        args=sgqlc.types.ArgDict(
            (
                ("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="createdBy", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) The number of audiences matching the filters

    Arguments:

    * `audience_id` (`UUID`): Audience associated with the recipient
    * `search` (`String`): Search text to filter the audiences list,
      returning those whose labels contain the specified text
    * `created_by` (`[String]`): Filter by creator using a list of
      user emails. It can include null to filter audiences without a
      creator
    """

    get_notification_audience_creators = sgqlc.types.Field(
        sgqlc.types.list_of("User"),
        graphql_name="getNotificationAudienceCreators",
        args=sgqlc.types.ArgDict(
            (
                ("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
            )
        ),
    )
    """(experimental) Retrieve users who created notification audiences.
    This may include null if there are audiences without a creator

    Arguments:

    * `audience_id` (`UUID`): Audience associated with the recipient
    * `search` (`String`): Search text to filter the audiences list,
      returning those whose labels contain the specified text
    """

    get_notification_counts = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(NotificationRecordCount)),
        graphql_name="getNotificationCounts",
    )
    """Get notification counts over the last 30 days"""

    get_notification_settings_for_ootb = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(NotificationSetting)),
        graphql_name="getNotificationSettingsForOotb",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "anomaly_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(IncidentSubType),
                        graphql_name="anomalyType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get OOTB notification settings for the given asset

    Arguments:

    * `mcon` (`String!`): Asset MCON
    * `anomaly_type` (`IncidentSubType!`): OOTB anomaly type
    """

    get_notification_settings_for_audiences = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(NotificationSetting)),
        graphql_name="getNotificationSettingsForAudiences",
        args=sgqlc.types.ArgDict(
            (
                (
                    "label_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labelNames", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) The notification settings that will be used for the
    given audiences

    Arguments:

    * `label_names` (`[String]`): Label names.
    """

    get_collection_dataset_list = sgqlc.types.Field(
        CollectionDataSetConnection,
        graphql_name="getCollectionDatasetList",
        args=sgqlc.types.ArgDict(
            (
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get datasets in the account, including blocked datasets and
    dataset unblocked recently

    Arguments:

    * `resource_id` (`UUID`): Filter by resource id
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_collection_block_list = sgqlc.types.Field(
        CollectionBlockConnection,
        graphql_name="getCollectionBlockList",
        args=sgqlc.types.ArgDict(
            (
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                (
                    "parent_scope",
                    sgqlc.types.Arg(
                        CollectionBlockListParentScopeInput,
                        graphql_name="parentScope",
                        default=None,
                    ),
                ),
                (
                    "target_object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(CollectionPreferenceTargetObjectType),
                        graphql_name="targetObjectTypes",
                        default=None,
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get entities blocked from metadata collection in my account.

    Arguments:

    * `resource_id` (`UUID`): Filter by resource id
    * `project` (`String`): DEPRECATED: use parent_scope instead
    * `parent_scope` (`CollectionBlockListParentScopeInput`): The
      parent scope of target objects. If not provided then all
      collection blocks for the account will be returned.
    * `target_object_types`
      (`[CollectionPreferenceTargetObjectType]`): Only return
      collection blocks targeting these object types.
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_allow_list = sgqlc.types.Field(
        sgqlc.types.list_of(ProjectAllowType),
        graphql_name="getAllowList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceUuid", default=None
                    ),
                ),
                (
                    "project_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="projectNames", default=None
                    ),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=1000)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(general availability) Get the list of projects and datasets that
    are allowed to be fetched from the warehouse.

    Arguments:

    * `resource_uuid` (`UUID!`): The UUID of the warehouse from which
      to fetch the allowed projects datasets
    * `project_names` (`[String]`): The list of project names to
      filter the allowed datasets from
    * `first` (`Int`): The number of datasets to return. Defaults to
      1000. (default: `1000`)
    * `offset` (`Int`): The offset from the beginning of the list.
      Defaults to 0.
    """

    get_workspaces_allow_list_for_power_bi_reports_collection = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getWorkspacesAllowListForPowerBiReportsCollection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Get the list of workspaces for which
    metadata collection is allowed on this account.

    Arguments:

    * `connection_uuid` (`UUID!`): The UUID of the connection that
      handles the Power BI Reports collection.
    """

    get_asset_collection_preferences = sgqlc.types.Field(
        AssetCollectionPreferencesConnection,
        graphql_name="getAssetCollectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("asset_type", sgqlc.types.Arg(String, graphql_name="assetType", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get asset collection preferences for my account.

    Arguments:

    * `resource_id` (`UUID`): Filter by resource id
    * `asset_type` (`String`): Filter by asset type
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_fivetran_connectors = sgqlc.types.Field(
        FivetranConnectorConnection,
        graphql_name="getFivetranConnectors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
                (
                    "services",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="services", default=None
                    ),
                ),
                (
                    "statuses",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(FivetranConnectorStatuses),
                        graphql_name="statuses",
                        default=None,
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get fivetran connectors

    Arguments:

    * `mcons` (`[String]`): Filter by a list of MCONs
    * `table_mcons` (`[String]`): Filter by a list of table MCONs
    * `services` (`[String]`): Filter by a list of fivetran connector
      sources
    * `statuses` (`[FivetranConnectorStatuses]`): Filter by a list of
      fivetran connector statuses
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_pii_filtering_preferences = sgqlc.types.Field(
        PiiFilteringPreferencesOutput, graphql_name="getPiiFilteringPreferences"
    )
    """The PII filter settings for the user's account."""

    get_pii_filters = sgqlc.types.Field(
        sgqlc.types.list_of(PiiFilterOutput), graphql_name="getPiiFilters"
    )
    """The possible PII filters for the user's account."""

    get_pii_filter_metrics = sgqlc.types.Field(
        sgqlc.types.list_of(PiiFilterMetricOutput),
        graphql_name="getPiiFilterMetrics",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="resourceIds", default=None
                    ),
                ),
                (
                    "filter_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="filterNames", default=None
                    ),
                ),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
                (
                    "earliest_job_completion_time",
                    sgqlc.types.Arg(
                        DateTime, graphql_name="earliestJobCompletionTime", default=None
                    ),
                ),
                (
                    "latest_job_completion_time",
                    sgqlc.types.Arg(DateTime, graphql_name="latestJobCompletionTime", default=None),
                ),
                ("number_of_jobs", sgqlc.types.Arg(Int, graphql_name="numberOfJobs", default=100)),
            )
        ),
    )
    """PII filter metrics per job run.

    Arguments:

    * `resource_ids` (`[UUID]`): UUIDs of which resources to look for.
    * `filter_names` (`[String]`): Names of specific PII filters to
      look for.
    * `job_types` (`[String]`): Specify job types to look for.
    * `earliest_job_completion_time` (`DateTime`): How far back to
      look for the job completion time.
    * `latest_job_completion_time` (`DateTime`): How recent to look
      for the job completion time.
    * `number_of_jobs` (`Int`): How many recent job runs to use in the
      metrics aggregation (maximum is 100). (default: `100`)
    """

    get_dbt_connections = sgqlc.types.Field(
        sgqlc.types.list_of(Connection), graphql_name="getDbtConnections"
    )
    """Get dbt connections"""

    get_dbt_connection_details = sgqlc.types.Field(
        DbtConnectionDetails,
        graphql_name="getDbtConnectionDetails",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Get dbt connection details

    Arguments:

    * `connection_id` (`String!`): dbt connection id
    """

    get_dbt_projects = sgqlc.types.Field(
        DbtProjectConnection,
        graphql_name="getDbtProjects",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(String, graphql_name="uuid", default=None)),
                ("project_name", sgqlc.types.Arg(String, graphql_name="projectName", default=None)),
                (
                    "connection_id",
                    sgqlc.types.Arg(String, graphql_name="connectionId", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get dbt projects

    Arguments:

    * `uuid` (`String`): dbt project id
    * `project_name` (`String`): dbt project name
    * `connection_id` (`String`): dbt connection id
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_dbt_jobs = sgqlc.types.Field(
        DbtJobConnection,
        graphql_name="getDbtJobs",
        args=sgqlc.types.ArgDict(
            (
                ("project_id", sgqlc.types.Arg(UUID, graphql_name="projectId", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get dbt jobs

    Arguments:

    * `project_id` (`UUID`): dbt project id
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_dbt_nodes = sgqlc.types.Field(
        DbtNodeConnection,
        graphql_name="getDbtNodes",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(String, graphql_name="uuid", default=None)),
                (
                    "dbt_project_uuid",
                    sgqlc.types.Arg(String, graphql_name="dbtProjectUuid", default=None),
                ),
                ("table_mcon", sgqlc.types.Arg(String, graphql_name="tableMcon", default=None)),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
                (
                    "dbt_unique_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="dbtUniqueIds", default=None
                    ),
                ),
                (
                    "resource_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="resourceTypes", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get dbt nodes

    Arguments:

    * `uuid` (`String`): Filter by UUID of dbt node
    * `dbt_project_uuid` (`String`): Filter by UUID of dbt project
    * `table_mcon` (`String`): Filter by table MCON (deprecated, use
      tableMcons instead)
    * `table_mcons` (`[String]`): Filter by list of table MCON
    * `dbt_unique_ids` (`[String]`): Filter by list of dbt node
      unique_id
    * `resource_types` (`[String]`): Filter by dbt node resource type
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_dbt_runs = sgqlc.types.Field(
        DbtRunConnection,
        graphql_name="getDbtRuns",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(String, graphql_name="uuid", default=None)),
                (
                    "dbt_project_uuid",
                    sgqlc.types.Arg(String, graphql_name="dbtProjectUuid", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get dbt runs

    Arguments:

    * `uuid` (`String`): Filter by UUID of dbt node
    * `dbt_project_uuid` (`String`): Filter by UUID of dbt project
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_dbt_models = sgqlc.types.Field(
        DbtModelsConnection,
        graphql_name="getDbtModels",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("name_filter", sgqlc.types.Arg(String, graphql_name="nameFilter", default=None)),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
            )
        ),
    )
    """Get dbt models

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `name_filter` (`String`): Filter the models for which the name
      start with this string
    * `table_mcons` (`[String]`): Filter the models for which the mcon
      is in this list
    """

    get_dbt_model_results = sgqlc.types.Field(
        DbtModelResultsConnection,
        graphql_name="getDbtModelResults",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                (
                    "run_start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runStartTime", default=None
                    ),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runEndTime", default=None
                    ),
                ),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="status", default=None
                    ),
                ),
                (
                    "command",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="command", default=None
                    ),
                ),
                (
                    "model",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="model", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="mcon", default=None),
                ),
                (
                    "job_execution_id",
                    sgqlc.types.Arg(UUID, graphql_name="jobExecutionId", default=None),
                ),
                ("sort_order", sgqlc.types.Arg(String, graphql_name="sortOrder", default="desc")),
                (
                    "resource_type",
                    sgqlc.types.Arg(NodeType, graphql_name="resourceType", default=None),
                ),
            )
        ),
    )
    """Get dbt model results

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `run_start_time` (`DateTime!`): Beginning of time window to
      filter run start times
    * `run_end_time` (`DateTime!`): End of time window to filter run
      start times
    * `status` (`[String]`): Status(es) to filter run results
    * `command` (`[String]`): dbt command(s) to filter run results
    * `model` (`[String]`): dbt model ids to filter run results
    * `mcon` (`[String]`): Associated table MCONs to filter run
      results
    * `job_execution_id` (`UUID`): Filter by dbt job execution uuid
    * `sort_order` (`String`): Specify asc to return results by
      ascending completion time (default: `"desc"`)
    * `resource_type` (`NodeType`): Filter by dbt node resource type
    """

    get_dbt_model_results_count = sgqlc.types.Field(
        Int,
        graphql_name="getDbtModelResultsCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "run_start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runStartTime", default=None
                    ),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runEndTime", default=None
                    ),
                ),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="status", default=None
                    ),
                ),
            )
        ),
    )
    """Get the count of dbt model results

    Arguments:

    * `run_start_time` (`DateTime!`): Beginning of time window to
      filter run start times
    * `run_end_time` (`DateTime!`): End of time window to filter run
      start times
    * `status` (`[String]`): Status(es) to filter run results
    """

    get_dbt_node_results_count = sgqlc.types.Field(
        DbtNodeResultCount,
        graphql_name="getDbtNodeResultsCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "run_start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runStartTime", default=None
                    ),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runEndTime", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="status", default=None
                    ),
                ),
                (
                    "command",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="command", default=None
                    ),
                ),
                (
                    "model",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="model", default=None
                    ),
                ),
                (
                    "job_execution_id",
                    sgqlc.types.Arg(UUID, graphql_name="jobExecutionId", default=None),
                ),
            )
        ),
    )
    """(experimental) Get the count of dbt nodes by type

    Arguments:

    * `run_start_time` (`DateTime!`): Beginning of time window to
      filter run start times
    * `run_end_time` (`DateTime!`): End of time window to filter run
      start times
    * `mcon` (`String!`): Associated table MCONs to filter run results
    * `status` (`[String]`): Status(es) to filter run results
    * `command` (`[String]`): dbt command(s) to filter run results
    * `model` (`[String]`): dbt model ids to filter run results
    * `job_execution_id` (`UUID`): Filter by dbt job execution uuid
    """

    get_dbt_run_steps = sgqlc.types.Field(
        sgqlc.types.list_of("DbtRunStep"),
        graphql_name="getDbtRunSteps",
        args=sgqlc.types.ArgDict(
            (
                (
                    "node_unique_id",
                    sgqlc.types.Arg(String, graphql_name="nodeUniqueId", default=None),
                ),
                ("table_mcon", sgqlc.types.Arg(String, graphql_name="tableMcon", default=None)),
                (
                    "completed_at_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="completedAtStartTime", default=None),
                ),
                (
                    "completed_at_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="completedAtEndTime", default=None),
                ),
                ("status", sgqlc.types.Arg(String, graphql_name="status", default=None)),
                ("dbt_run_id", sgqlc.types.Arg(String, graphql_name="dbtRunId", default=None)),
                ("sort_field", sgqlc.types.Arg(String, graphql_name="sortField", default=None)),
                (
                    "sort_direction",
                    sgqlc.types.Arg(String, graphql_name="sortDirection", default=None),
                ),
            )
        ),
    )
    """Get dbt run steps

    Arguments:

    * `node_unique_id` (`String`): dbt test id
    * `table_mcon` (`String`): MCON of the associated table
    * `completed_at_start_time` (`DateTime`): Filter the results by
      those that completed on or after this time
    * `completed_at_end_time` (`DateTime`): Filter the results by
      those that completed before this time
    * `status` (`String`): Filter results by completion status
    * `dbt_run_id` (`String`): Filter results by dbt run id
    * `sort_field` (`String`): Sort by the fields: created_time,
      updated_time, started_at, completed_at. The default value is
      completed_at
    * `sort_direction` (`String`): Sort direction: asc or desc. The
      default value is asc
    """

    get_dbt_test_results_count = sgqlc.types.Field(
        Int,
        graphql_name="getDbtTestResultsCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "run_start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runStartTime", default=None
                    ),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runEndTime", default=None
                    ),
                ),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="status", default=None
                    ),
                ),
            )
        ),
    )
    """Get the count of dbt test results

    Arguments:

    * `run_start_time` (`DateTime!`): Beginning of time window to
      filter run start times
    * `run_end_time` (`DateTime!`): End of time window to filter run
      start times
    * `status` (`[String]`): Status(es) to filter run results
    """

    get_dbt_test_results = sgqlc.types.Field(
        DbtTestResultsConnection,
        graphql_name="getDbtTestResults",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                (
                    "run_start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runStartTime", default=None
                    ),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runEndTime", default=None
                    ),
                ),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="status", default=None
                    ),
                ),
                (
                    "model",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="model", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="mcon", default=None),
                ),
            )
        ),
    )
    """Get dbt test results

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `run_start_time` (`DateTime!`): Beginning of time window to
      match run start times
    * `run_end_time` (`DateTime!`): End of time window to match run
      start times
    * `status` (`[String]`): Status(es) to match run results
    * `model` (`[String]`): dbt model ids to filter run results
    * `mcon` (`[String]`): Associated table MCONs to filter run
      results
    """

    get_dbt_upload_url = sgqlc.types.Field(
        String,
        graphql_name="getDbtUploadUrl",
        args=sgqlc.types.ArgDict(
            (
                (
                    "project_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="projectName", default=None
                    ),
                ),
                (
                    "invocation_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="invocationId", default=None
                    ),
                ),
                (
                    "file_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="fileName", default=None
                    ),
                ),
            )
        ),
    )
    """Get the Dbt artifacts presigned upload url

    Arguments:

    * `project_name` (`String!`): dbt project name
    * `invocation_id` (`String!`): dbt invocation id
    * `file_name` (`String!`): name of the file for the upload
    """

    get_dbt_last_run_results = sgqlc.types.Field(
        DbtModelResultsConnection,
        graphql_name="getDbtLastRunResults",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                (
                    "run_start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runStartTime", default=None
                    ),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="runEndTime", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="status",
                        default=None,
                    ),
                ),
                (
                    "model",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="model", default=None
                    ),
                ),
            )
        ),
    )
    """Get dbt model results for latest relevant run

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `run_start_time` (`DateTime!`): Beginning of time window to
      filter run start times
    * `run_end_time` (`DateTime!`): End of time window to filter run
      start times
    * `mcons` (`[String]!`): Associated table MCONs to filter run
      results
    * `status` (`[String]!`): Status(es) to filter run results
    * `model` (`[String]`): dbt model ids to filter run results
    """

    get_dbt_job_executions = sgqlc.types.Field(
        DbtJobExecutionsConnection,
        graphql_name="getDbtJobExecutions",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                (
                    "job_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobUuid", default=None
                    ),
                ),
                (
                    "job_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="jobStartTime", default=None),
                ),
                (
                    "job_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="jobEndTime", default=None),
                ),
                (
                    "job_execution_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="jobExecutionUuid", default=None),
                ),
                (
                    "sort_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sortBy", default=None
                    ),
                ),
            )
        ),
    )
    """Get dbt job executions for a given job uuid

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `job_uuid` (`String!`): dbt job uuid
    * `job_start_time` (`DateTime`): Beginning of time window to
      filter job start times
    * `job_end_time` (`DateTime`): End of time window to filter job
      start times
    * `job_execution_uuid` (`UUID`): UUID of job execution
    * `sort_by` (`[String]`): Fields to sort by
    """

    get_exec_dashboard_metrics = sgqlc.types.Field(
        sgqlc.types.list_of(ExecDashboardMetric),
        graphql_name="getExecDashboardMetrics",
        args=sgqlc.types.ArgDict(
            (
                (
                    "metrics",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(ExecDashboardMetrics)),
                        graphql_name="metrics",
                        default=None,
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("period_count", sgqlc.types.Arg(Int, graphql_name="periodCount", default=None)),
                (
                    "period_unit",
                    sgqlc.types.Arg(PeriodGrouping, graphql_name="periodUnit", default=None),
                ),
                (
                    "period_grouping",
                    sgqlc.types.Arg(PeriodGrouping, graphql_name="periodGrouping", default=None),
                ),
                (
                    "period_total",
                    sgqlc.types.Arg(Boolean, graphql_name="periodTotal", default=None),
                ),
                (
                    "period_include_current",
                    sgqlc.types.Arg(Boolean, graphql_name="periodIncludeCurrent", default=None),
                ),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "key_assets_only",
                    sgqlc.types.Arg(Boolean, graphql_name="keyAssetsOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "monitor_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput),
                        graphql_name="monitorTags",
                        default=None,
                    ),
                ),
                (
                    "incident_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="incidentTypes", default=None
                    ),
                ),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "audience_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="audienceIds", default=None
                    ),
                ),
            )
        ),
    )
    """Get one or more exec dashboard metrics.

    Arguments:

    * `metrics` (`[ExecDashboardMetrics]!`)None
    * `start_time` (`DateTime`): Start time to get time-bound values
      for.
    * `end_time` (`DateTime`): End time to get time-bound values for.
    * `period_count` (`Int`): Number of periods to get time-bound
      values for.
    * `period_unit` (`PeriodGrouping`): Time unit to use with the
      period_count, if not defined use period_grouping.
    * `period_grouping` (`PeriodGrouping`): Time buckets to group
      time-bound metrics by.
    * `period_total` (`Boolean`): Indicates if must return a single
      value with the total.
    * `period_include_current` (`Boolean`): Indicates if must include
      until current days (otherwise will include only full
      weeks/months).
    * `resource_id` (`UUID`): Resource id to filter.
    * `domain_id` (`UUID`): Domain id to filter. Deprecated, please
      use domain_ids
    * `key_assets_only` (`Boolean`): Only include key assets.
    * `tags` (`[TagKeyValuePairInput]`): Tags to filter.
    * `monitor_tags` (`[TagKeyValuePairInput]`): Monitor tags to
      filter.
    * `incident_types` (`[String]`): Filter by type of incident (e.g.
      anomalies)
    * `include_feedback` (`[String]`): Filter by user feedback
    * `exclude_feedback` (`[String]`): Exclude by user feedback
    * `domain_ids` (`[UUID]`): Domain ids to filter.
    * `data_product_ids` (`[UUID]`): Data Product UUIDs.
    * `audience_ids` (`[UUID]`): Audience UUIDs.
    """

    get_exec_dashboard_tables = sgqlc.types.Field(
        sgqlc.types.list_of(ExecDashboardTable),
        graphql_name="getExecDashboardTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "tables",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(ExecDashboardTables)),
                        graphql_name="tables",
                        default=None,
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("period_count", sgqlc.types.Arg(Int, graphql_name="periodCount", default=None)),
                (
                    "period_unit",
                    sgqlc.types.Arg(PeriodGrouping, graphql_name="periodUnit", default=None),
                ),
                (
                    "period_grouping",
                    sgqlc.types.Arg(PeriodGrouping, graphql_name="periodGrouping", default=None),
                ),
                (
                    "period_total",
                    sgqlc.types.Arg(Boolean, graphql_name="periodTotal", default=None),
                ),
                (
                    "period_include_current",
                    sgqlc.types.Arg(Boolean, graphql_name="periodIncludeCurrent", default=None),
                ),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "key_assets_only",
                    sgqlc.types.Arg(Boolean, graphql_name="keyAssetsOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "incident_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="incidentTypes", default=None
                    ),
                ),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "audience_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="audienceIds", default=None
                    ),
                ),
            )
        ),
    )
    """Get one or more exec dashboard metrics.

    Arguments:

    * `tables` (`[ExecDashboardTables]!`)None
    * `start_time` (`DateTime`): Start time to get time-bound values
      for.
    * `end_time` (`DateTime`): End time to get time-bound values for.
    * `period_count` (`Int`): Number of periods to get time-bound
      values for.
    * `period_unit` (`PeriodGrouping`): Time unit to use with the
      period_count, if not defined use period_grouping.
    * `period_grouping` (`PeriodGrouping`): Time buckets to group
      time-bound metrics by.
    * `period_total` (`Boolean`): Indicates if must return a single
      value with the total.
    * `period_include_current` (`Boolean`): Indicates if must include
      until current days (otherwise will include only full
      weeks/months).
    * `resource_id` (`UUID`): Resource id to filter.
    * `domain_id` (`UUID`): Domain id to filter. Please use
      domain_ids.
    * `key_assets_only` (`Boolean`): Only include key assets.
    * `tags` (`[TagKeyValuePairInput]`): Tags to filter.
    * `incident_types` (`[String]`): Filter by type of incident (e.g.
      anomalies)
    * `include_feedback` (`[String]`): Filter by user feedback
    * `exclude_feedback` (`[String]`): Exclude by user feedback
    * `domain_ids` (`[UUID]`): Domain ids to filter.
    * `data_product_ids` (`[UUID]`): Data Product UUIDs.
    * `audience_ids` (`[UUID]`): Audience UUIDs.
    """

    get_hosting_info = sgqlc.types.Field(
        HostingInformation,
        graphql_name="getHostingInfo",
        args=sgqlc.types.ArgDict(
            (
                (
                    "env_configuration",
                    sgqlc.types.Arg(
                        AwsEnvConfiguration, graphql_name="envConfiguration", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Get the current hosting environment
    information for the current              authorized user

    Arguments:

    * `env_configuration` (`AwsEnvConfiguration`): Type of env
      configuration to get the hosting information for
      (primary/secondary). If not specified, primary is assumed
    """

    get_deployment_info = sgqlc.types.Field(DeploymentInfo, graphql_name="getDeploymentInfo")
    """(general availability) DEPRECATED. Get the current deployment
    environment information for the current              authorized
    user
    """

    get_custom_users = sgqlc.types.Field(
        CustomUserConnection,
        graphql_name="getCustomUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_user_id",
                    sgqlc.types.Arg(String, graphql_name="customUserId", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get all unified users

    Arguments:

    * `custom_user_id` (`String`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_unified_users = sgqlc.types.Field(
        "UnifiedUserConnection",
        graphql_name="getUnifiedUsers",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(String, graphql_name="uuid", default=None)),
                (
                    "display_name_search",
                    sgqlc.types.Arg(String, graphql_name="displayNameSearch", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get all unified users

    Arguments:

    * `uuid` (`String`)None
    * `display_name_search` (`String`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_unified_user_assignments = sgqlc.types.Field(
        "UnifiedUserAssignmentConnection",
        graphql_name="getUnifiedUserAssignments",
        args=sgqlc.types.ArgDict(
            (
                (
                    "unified_user_id",
                    sgqlc.types.Arg(String, graphql_name="unifiedUserId", default=None),
                ),
                ("object_mcon", sgqlc.types.Arg(String, graphql_name="objectMcon", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get all unified user assignments

    Arguments:

    * `unified_user_id` (`String`)None
    * `object_mcon` (`String`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_monte_carlo_config_templates = sgqlc.types.Field(
        MonteCarloConfigTemplateConnection,
        graphql_name="getMonteCarloConfigTemplates",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
            )
        ),
    )
    """Get existing Monte Carlo config templates

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `namespace` (`String`)None
    """

    export_monte_carlo_config_templates = sgqlc.types.Field(
        MonteCarloConfigTemplateExportResponse,
        graphql_name="exportMonteCarloConfigTemplates",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="monitorUuids", default=None
                    ),
                ),
                (
                    "notification_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="notificationUuids", default=None
                    ),
                ),
                ("export_name", sgqlc.types.Arg(Boolean, graphql_name="exportName", default=False)),
            )
        ),
    )
    """Export Monte Carlo config templates from existing custom monitors

    Arguments:

    * `monitor_uuids` (`[UUID]`): List of custom monitor uuids to
      export
    * `notification_uuids` (`[UUID]`): List of notifications uuids to
      export
    * `export_name` (`Boolean`): Include the resource name in the
      export (default: `false`)
    """

    export_latest_version_monitor_replacement_templates = sgqlc.types.Field(
        MonteCarloConfigTemplateExportResponse,
        graphql_name="exportLatestVersionMonitorReplacementTemplates",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
                (
                    "collection_lag_hours_for_day_grouping",
                    sgqlc.types.Arg(
                        Int, graphql_name="collectionLagHoursForDayGrouping", default=24
                    ),
                ),
                (
                    "collection_lag_hours_for_hour_grouping",
                    sgqlc.types.Arg(
                        Int, graphql_name="collectionLagHoursForHourGrouping", default=2
                    ),
                ),
                ("validate", sgqlc.types.Arg(Boolean, graphql_name="validate", default=True)),
            )
        ),
    )
    """(experimental) Export Monte Carlo config templates for the latest-
    version replacements of the specified monitors. Currently only
    converts Dimension Tracking to Metric Monitor.

    Arguments:

    * `monitor_uuids` (`[UUID!]!`): List of UUIDs for monitors to
      convert
    * `namespace` (`String`): Namespace to export monitors from. If
      neither namespace nor monitor UUID list is provided, all
      monitors will be exported
    * `collection_lag_hours_for_day_grouping` (`Int`): Collection lag
      hours to use for monitors that group by day (default: `24`)
    * `collection_lag_hours_for_hour_grouping` (`Int`): Collection lag
      hours to use for monitors that group by hour (default: `2`)
    * `validate` (`Boolean`): Whether to validate the exported config
      template (default: `true`)
    """

    export_dimension_tracking_monitor_migration_templates = sgqlc.types.Field(
        MonteCarloConfigTemplateExportResponse,
        graphql_name="exportDimensionTrackingMonitorMigrationTemplates",
        args=sgqlc.types.ArgDict(
            (
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
                ("validate", sgqlc.types.Arg(Boolean, graphql_name="validate", default=True)),
            )
        ),
    )
    """(experimental) Export Monte Carlo config templates for migrated
    Dimension Tracking monitors.

    Arguments:

    * `namespace` (`String`): Filter results to the given namespace
      only.
    * `validate` (`Boolean`): Whether to validate the exported config
      template (default: `true`)
    """

    get_monte_carlo_config_template_update_state = sgqlc.types.Field(
        MonteCarloConfigTemplateUpdateAsyncState,
        graphql_name="getMonteCarloConfigTemplateUpdateState",
        args=sgqlc.types.ArgDict(
            (
                (
                    "update_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="updateUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Get result of async Monte Carlo config template update

    Arguments:

    * `update_uuid` (`UUID!`): UUID of update to fetch result for
    """

    get_correlation_sampling_metadata = sgqlc.types.Field(
        CorrelationSamplingMetadata,
        graphql_name="getCorrelationSamplingMetadata",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default="Table MCON"
                    ),
                ),
            )
        ),
    )
    """Provides initial information for sampling requests (e.g. time axis
    candidates, explanatory fields, etc.

    Arguments:

    * `mcon` (`String!`)None (default: `"Table MCON"`)
    """

    detect_time_axis_intrinsic_delta = sgqlc.types.Field(
        "TimeAxisDeltaDetectionResult",
        graphql_name="detectTimeAxisIntrinsicDelta",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default="Table MCON"
                    ),
                ),
                (
                    "time_axis",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="timeAxis",
                        default="Time axis field name",
                    ),
                ),
                (
                    "anchor_event",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID),
                        graphql_name="anchorEvent",
                        default="Anomaly event used for finding the time axis and intrinsic time overlap",
                    ),
                ),
            )
        ),
    )
    """Detects time delta between the selected time axis and intrinsic
    time

    Arguments:

    * `mcon` (`String!`)None (default: `"Table MCON"`)
    * `time_axis` (`String!`)None (default: `"Time axis field name"`)
    * `anchor_event` (`UUID!`)None (default: `"Anomaly event used for
      finding the time axis and intrinsic time overlap"`)
    """

    perform_correlation_sampling = sgqlc.types.Field(
        CorrelationSamplingResult,
        graphql_name="performCorrelationSampling",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                (
                    "time_axis",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="timeAxis", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                ("max_values", sgqlc.types.Arg(Int, graphql_name="maxValues", default=5)),
                ("max_rows", sgqlc.types.Arg(Int, graphql_name="maxRows", default=1000)),
            )
        ),
    )
    """Samples value distribution data alongside the time axis

    Arguments:

    * `mcon` (`String!`): MCON of the sampled table
    * `field` (`String!`): Field to be sampled
    * `time_axis` (`String!`): Time axis field used for sampling
    * `start_time` (`DateTime!`): Start time for sampling
    * `end_time` (`DateTime!`): End time for sampling
    * `max_values` (`Int`): Maximum number of top values (the rest is
      aggregated in "others") (default: `5`)
    * `max_rows` (`Int`): Maximum number of rows returned (default:
      `1000`)
    """

    perform_correlation_sampling_with_time_travel = sgqlc.types.Field(
        CorrelationSamplingResult,
        graphql_name="performCorrelationSamplingWithTimeTravel",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                ("max_values", sgqlc.types.Arg(Int, graphql_name="maxValues", default=5)),
                ("max_rows", sgqlc.types.Arg(Int, graphql_name="maxRows", default=1000)),
            )
        ),
    )
    """Samples value distribution data alongside the time axis

    Arguments:

    * `mcon` (`String!`): MCON of the sampled table
    * `field` (`String!`): Field to be sampled
    * `start_time` (`DateTime!`): Start time for sampling
    * `end_time` (`DateTime!`): End time for sampling
    * `max_values` (`Int`): Maximum number of top values (the rest is
      aggregated in "others") (default: `5`)
    * `max_rows` (`Int`): Maximum number of rows returned (default:
      `1000`)
    """

    perform_field_health_sampling = sgqlc.types.Field(
        FieldHealthSampling,
        graphql_name="performFieldHealthSampling",
        args=sgqlc.types.ArgDict(
            (
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metric", default=None
                    ),
                ),
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                ("max_rows", sgqlc.types.Arg(Int, graphql_name="maxRows", default=1000)),
                ("event_uuid", sgqlc.types.Arg(UUID, graphql_name="eventUuid", default=None)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=None)),
            )
        ),
    )
    """Samples value distribution data alongside the time axis

    Arguments:

    * `field` (`String!`): Field to be sampled
    * `metric` (`String!`): Metric to be sampled
    * `monitor_uuid` (`UUID!`): The Monitor UUID that monitors the
      field health
    * `start_time` (`DateTime!`): Start time for sampling
    * `end_time` (`DateTime!`): End time for sampling
    * `max_rows` (`Int`): Maximum number of rows returned (default:
      `1000`)
    * `event_uuid` (`UUID`): Optional UUID of an event that contains
      field metric anomaly
    * `dry_run` (`Boolean`): Defaults to true, only fetch the query,
      do not run
    """

    perform_field_health_sampling_v2 = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="performFieldHealthSamplingV2",
        args=sgqlc.types.ArgDict(
            (
                ("event_uuid", sgqlc.types.Arg(UUID, graphql_name="eventUuid", default=None)),
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metric", default=None
                    ),
                ),
                ("max_rows", sgqlc.types.Arg(Int, graphql_name="maxRows", default=1000)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),
            )
        ),
    )
    """Samples value distribution data alongside the time axis

    Arguments:

    * `event_uuid` (`UUID`): Optional UUID of an event that contains
      field metric anomaly
    * `field` (`String!`): Field to be sampled
    * `metric` (`String!`): Metric to be sampled
    * `max_rows` (`Int`): Maximum number of rows returned (default:
      `1000`)
    * `dry_run` (`Boolean`): Defaults to false, only fetch the query,
      do not run (default: `false`)
    """

    perform_field_health_sampling_v3 = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="performFieldHealthSamplingV3",
        args=sgqlc.types.ArgDict(
            (
                (
                    "event_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="eventUuid", default=None
                    ),
                ),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SamplingEnabledMetricTypes),
                        graphql_name="metric",
                        default=None,
                    ),
                ),
                ("condition", sgqlc.types.Arg(String, graphql_name="condition", default=None)),
                ("segment_by", sgqlc.types.Arg(String, graphql_name="segmentBy", default=None)),
                ("max_rows", sgqlc.types.Arg(Int, graphql_name="maxRows", default=1000)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=True)),
                (
                    "return_total_count",
                    sgqlc.types.Arg(Boolean, graphql_name="returnTotalCount", default=False),
                ),
                (
                    "row_sampling_config",
                    sgqlc.types.Arg(
                        MonitorSamplingConfigInput, graphql_name="rowSamplingConfig", default=None
                    ),
                ),
                (
                    "include_explanation",
                    sgqlc.types.Arg(Boolean, graphql_name="includeExplanation", default=False),
                ),
            )
        ),
    )
    """(experimental) Construct or run a query to sample data based on a
    field metric anomaly

    Arguments:

    * `event_uuid` (`UUID!`): UUID of an event that contains field
      metric anomaly
    * `field` (`String`): Anomalous field. This is required if the
      anomaly (metric type dependent) involves a field.
    * `metric` (`SamplingEnabledMetricTypes!`): Metric type of the
      anomaly.
    * `condition` (`String`): Condition to be used for sampling. Only
      exact results from getFieldHealthSamplingConditions API response
      are accepted.
    * `segment_by` (`String`): Table field to be used to group
      results.
    * `max_rows` (`Int`): Maximum number of rows returned (default:
      `1000`)
    * `dry_run` (`Boolean`): Defaults to false, only fetch the query,
      do not run (default: `true`)
    * `return_total_count` (`Boolean`): Returns the total count of
      rows from the sampling query (default: `false`)
    * `row_sampling_config` (`MonitorSamplingConfigInput`): Sampling
      configuration to only read a subset of the data
    * `include_explanation` (`Boolean`): Include the explanation field
      in the results (only supported for agent monitors, and only
      included when evaluating prompts) (default: `false`)
    """

    get_field_health_sampling_conditions = sgqlc.types.Field(
        FieldHealthSamplingConditionsResponse,
        graphql_name="getFieldHealthSamplingConditions",
        args=sgqlc.types.ArgDict(
            (
                (
                    "event_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="eventUuid", default=None
                    ),
                ),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SamplingEnabledMetricTypes),
                        graphql_name="metric",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Returns the conditions that can be used for field
    health sampling

    Arguments:

    * `event_uuid` (`UUID!`): UUID of an event that contains field
      metric anomaly
    * `field` (`String`): Anomalous field. This is required if the
      anomaly (metric type dependent) involves a field.
    * `metric` (`SamplingEnabledMetricTypes!`): Metric type of the
      anomaly.
    """

    get_rca_result = sgqlc.types.Field(
        "RcaResult",
        graphql_name="getRcaResult",
        args=sgqlc.types.ArgDict(
            (("event_uuid", sgqlc.types.Arg(UUID, graphql_name="eventUuid", default=None)),)
        ),
    )
    """Arguments:

    * `event_uuid` (`UUID`)None
    """

    get_rca_job_result = sgqlc.types.Field(
        "RcaResult",
        graphql_name="getRcaJobResult",
        args=sgqlc.types.ArgDict(
            (("job_uuid", sgqlc.types.Arg(UUID, graphql_name="jobUuid", default=None)),)
        ),
    )
    """Arguments:

    * `job_uuid` (`UUID`)None
    """

    get_incident_rcas = sgqlc.types.Field(
        IncidentRcaData,
        graphql_name="getIncidentRcas",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Fetches all RCAs of all types for an
    incident and includes a primary rca which is the most important
    one for the incident

    Arguments:

    * `incident_uuid` (`UUID!`): Incident identifier
    """

    get_alert_rcas = sgqlc.types.Field(
        AlertRcaData,
        graphql_name="getAlertRcas",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Fetches all RCAs of all types for an alert and
    includes a primary rca which is the most important one for the
    alert

    Arguments:

    * `alert_uuid` (`UUID!`): Alert identifier
    """

    get_table_rcas = sgqlc.types.Field(
        sgqlc.types.list_of("ExtendedRca"),
        graphql_name="getTableRcas",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
            )
        ),
    )
    """Fetches all RCAs for a table

    Arguments:

    * `mcon` (`String!`): MC table unique identifier
    * `start_time` (`DateTime!`): Starting date to fetch RCAs from
    * `end_time` (`DateTime`): Optional end date to fetch RCAs,
      defaults to now
    """

    get_sensitivity = sgqlc.types.Field(
        "SensitivityThreshold",
        graphql_name="getSensitivity",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("event_type", sgqlc.types.Arg(String, graphql_name="eventType", default=None)),
                ("monitor_uuid", sgqlc.types.Arg(UUID, graphql_name="monitorUuid", default=None)),
            )
        ),
    )
    """Arguments:

    * `mcon` (`String`)None
    * `event_type` (`String`)None
    * `monitor_uuid` (`UUID`)None
    """

    thresholds = sgqlc.types.Field("ThresholdsData", graphql_name="thresholds")
    """Section describing various anomaly thresholds for the table"""

    get_thresholds = sgqlc.types.Field("ThresholdsData", graphql_name="getThresholds")
    """Section describing various anomaly thresholds for the table"""

    get_data_maintenance_entries = sgqlc.types.Field(
        sgqlc.types.list_of(DataMaintenanceEntry),
        graphql_name="getDataMaintenanceEntries",
        args=sgqlc.types.ArgDict(
            (("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),)
        ),
    )
    """(experimental) Fetch all exclusion windows for the given warehouse

    Arguments:

    * `dw_id` (`UUID`): Warehouse UUID
    """

    get_data_maintenance_entries_by_monitor = sgqlc.types.Field(
        sgqlc.types.list_of(DataMaintenanceEntry),
        graphql_name="getDataMaintenanceEntriesByMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorId", default=None
                    ),
                ),
                (
                    "time_series_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="timeSeriesUuid", default=None),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """(experimental) Fetch exclusion windows for the given monitor

    Arguments:

    * `monitor_id` (`UUID!`): Monitor UUID
    * `time_series_uuid` (`UUID`): Only return windows for a specific
      time series UUID
    * `start_time` (`DateTime`): Start time of maintenance period
    * `end_time` (`DateTime`): End time of maintenance period
    * `metric` (`String`): Metric to set maintenance period for.
      Deprecated: Use time_series_uuid instead
    * `field` (`String`): Field to set maintenance period for.
      Deprecated: Use time_series_uuid instead
    * `where_condition` (`String`): Where condition to set maintenance
      period for. Deprecated: Use time_series_uuid instead
    """

    get_data_maintenance_entries_by_mcon = sgqlc.types.Field(
        sgqlc.types.list_of(DataMaintenanceEntry),
        graphql_name="getDataMaintenanceEntriesByMcon",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "metric_type",
                    sgqlc.types.Arg(DataMaintenanceMetric, graphql_name="metricType", default=None),
                ),
            )
        ),
    )
    """(experimental) Fetch exclusion windows for the given MCON

    Arguments:

    * `mcon` (`String!`): MCON
    * `start_time` (`DateTime`): Start time of maintenance period
    * `end_time` (`DateTime`): End time of maintenance period
    * `metric_type` (`DataMaintenanceMetric`): Type of maintenance
      metric
    """

    get_data_maintenance_holiday_codes = sgqlc.types.Field(
        sgqlc.types.list_of(HolidayCode), graphql_name="getDataMaintenanceHolidayCodes"
    )
    """(experimental) Fetch list of supported countries and market codes
    for data maintenance
    """

    get_data_maintenance_holiday_names = sgqlc.types.Field(
        sgqlc.types.list_of(HolidayName),
        graphql_name="getDataMaintenanceHolidayNames",
        args=sgqlc.types.ArgDict(
            (
                (
                    "country_or_market_code",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="countryOrMarketCode",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Fetch list of supported holiday names

    Arguments:

    * `country_or_market_code` (`String!`): Country or market code
    """

    get_table_columns_lineage = sgqlc.types.Field(
        "TableColumnsLineageResult",
        graphql_name="getTableColumnsLineage",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """Column level lineage for a destination table

    Arguments:

    * `mcon` (`String`): Destination table mcon
    """

    get_derived_tables_partial_lineage = sgqlc.types.Field(
        DerivedTablesLineageResult,
        graphql_name="getDerivedTablesPartialLineage",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("column", sgqlc.types.Arg(String, graphql_name="column", default=None)),
                ("cursor", sgqlc.types.Arg(String, graphql_name="cursor", default=None)),
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=20)),
            )
        ),
    )
    """Tables and its columns that are influenced by the source table and
    column. Note we only return columns that are influenced by the
    source column in the response.

    Arguments:

    * `mcon` (`String`): source table mcon
    * `column` (`String`): source column
    * `cursor` (`String`): cursor for getting the next page
    * `page_size` (`Int`): number of derived tables to return in a
      call (default: `20`)
    """

    get_parsed_query = sgqlc.types.Field(
        ParsedQueryResult,
        graphql_name="getParsedQuery",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """The query, based on which the table's created

    Arguments:

    * `mcon` (`String`): Source table mcon
    """

    get_trace_tree_nodes = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("TraceNode")),
        graphql_name="getTraceTreeNodes",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "trace_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="traceId", default=None
                    ),
                ),
                (
                    "trace_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="traceStartTime", default=None),
                ),
                (
                    "trace_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="traceEndTime", default=None),
                ),
            )
        ),
    )
    """(experimental) Retrieve span tree for a given traceId

    Arguments:

    * `mcon` (`String!`): MCON of the table with agent observability
      traces
    * `trace_id` (`String!`): Trace ID to retrieve
    * `trace_start_time` (`DateTime`): Start time of the trace
      (inclusive)
    * `trace_end_time` (`DateTime`): End time of the trace (inclusive)
    """

    get_agent_span_groups = sgqlc.types.Field(
        AgentSpanTree,
        graphql_name="getAgentSpanGroups",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("trace_mode", sgqlc.types.Arg(Boolean, graphql_name="traceMode", default=False)),
                (
                    "trace_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="traceIds",
                        default=None,
                    ),
                ),
                (
                    "trace_timestamp",
                    sgqlc.types.Arg(DateTime, graphql_name="traceTimestamp", default=None),
                ),
            )
        ),
    )
    """(experimental) Retrieve agent log groups with observability data

    Arguments:

    * `mcon` (`String!`): MCON of the table with agent observability
      traces
    * `trace_mode` (`Boolean`): Consider all the spans (not only the
      recent ones), and sort them by start date. (default: `false`)
    * `trace_ids` (`[String!]`): Filter by specific trace IDs
    * `trace_timestamp` (`DateTime`): Filter by trace timestamp
      (inclusive) +- 1 hr
    """

    get_agent_span_sample = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="getAgentSpanSample",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "agent_span_filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilterInput)),
                        graphql_name="agentSpanFilters",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(FilterGroupInput, graphql_name="filters", default=None),
                ),
                (
                    "transforms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TransformInput)),
                        graphql_name="transforms",
                        default=None,
                    ),
                ),
                (
                    "evaluation_mode",
                    sgqlc.types.Arg(Boolean, graphql_name="evaluationMode", default=False),
                ),
                ("trace_mode", sgqlc.types.Arg(Boolean, graphql_name="traceMode", default=False)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=10)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                (
                    "span_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="spanIds",
                        default=None,
                    ),
                ),
                (
                    "trace_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="traceIds",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "trace_timestamp",
                    sgqlc.types.Arg(DateTime, graphql_name="traceTimestamp", default=None),
                ),
            )
        ),
    )
    """(experimental) Sample agent span data with optional transforms and
    filtering

    Arguments:

    * `mcon` (`String!`): MCON of the table with agent observability
      traces
    * `agent_span_filters` (`[AgentSpanFilterInput!]`): Filter by
      agent span fields (agent, workflow, task, span_name)
    * `filters` (`FilterGroupInput`): Structured SQL filtering
      conditions to apply to query
    * `transforms` (`[TransformInput!]`): Transforms to apply to the
      data source
    * `evaluation_mode` (`Boolean`): Return evaluation test columns
      only (prompts, completions, span_id, transform outputs)
      (default: `false`)
    * `trace_mode` (`Boolean`): Consider all the spans (not only the
      recent ones), and sort them by start date. (default: `false`)
    * `limit` (`Int`): Number of sample rows to return (max 100)
      (default: `10`)
    * `offset` (`Int`): Number of rows to skip before returning
      results (default: `0`)
    * `span_ids` (`[String!]`): Filter by specific span IDs (<= limit)
    * `trace_ids` (`[String!]`): Filter by specific trace IDs (<=
      limit)
    * `connection_id` (`UUID`): Connection UUID
    * `trace_timestamp` (`DateTime`): Filter by trace timestamp
      (inclusive) +- 1 hr
    """

    get_agent_span_sample_v2 = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="getAgentSpanSampleV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "agent_span_filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilterInput)),
                        graphql_name="agentSpanFilters",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(FilterGroupInput, graphql_name="filters", default=None),
                ),
                (
                    "transforms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TransformInput)),
                        graphql_name="transforms",
                        default=None,
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=10)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                (
                    "span_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="spanIds",
                        default=None,
                    ),
                ),
                (
                    "trace_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="traceIds",
                        default=None,
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "trace_timestamp",
                    sgqlc.types.Arg(DateTime, graphql_name="traceTimestamp", default=None),
                ),
                (
                    "ingestion_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="ingestionStartTime", default=None),
                ),
                (
                    "ingestion_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="ingestionEndTime", default=None),
                ),
                (
                    "select_expression_type",
                    sgqlc.types.Arg(
                        AgentMonitorSelectExpressionType,
                        graphql_name="selectExpressionType",
                        default="SPAN_TREE",
                    ),
                ),
            )
        ),
    )
    """(experimental) Sample agent span data with optional transforms and
    filtering

    Arguments:

    * `mcon` (`String!`): MCON of the table with agent observability
      traces
    * `agent_span_filters` (`[AgentSpanFilterInput!]`): Filter by
      agent span fields (agent, workflow, task, span_name)
    * `filters` (`FilterGroupInput`): Structured SQL filtering
      conditions to apply to query
    * `transforms` (`[TransformInput!]`): Transforms to apply to the
      data source
    * `limit` (`Int`): Number of sample rows to return (max 100)
      (default: `10`)
    * `offset` (`Int`): Number of rows to skip before returning
      results (default: `0`)
    * `span_ids` (`[String!]`): Filter by specific span IDs (<= limit)
    * `trace_ids` (`[String!]`): Filter by specific trace IDs (<=
      limit)
    * `connection_id` (`UUID`): Connection UUID
    * `trace_timestamp` (`DateTime`): Filter by trace timestamp
      (inclusive) +- 1 hr
    * `ingestion_start_time` (`DateTime`): Filter by span start time
      (inclusive)
    * `ingestion_end_time` (`DateTime`): Filter by span end time
    * `select_expression_type` (`AgentMonitorSelectExpressionType`):
      This is to explicitly specify the type of select expressions.
      But we will return the columns based on the validity of the
      query.Not providing the select_expression_type will default to
      SPAN_TREE. (default: `"SPAN_TREE"`)
    """

    evaluate_agent_monitor_data_source = sgqlc.types.Field(
        DataSourceEvaluationResult,
        graphql_name="evaluateAgentMonitorDataSource",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "transforms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TransformInput)),
                        graphql_name="transforms",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(FilterGroupInput, graphql_name="filters", default=None),
                ),
                (
                    "agent_span_filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilterInput)),
                        graphql_name="agentSpanFilters",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get agent span schema from base trace table

    Arguments:

    * `mcon` (`String!`): MCON to evaluate
    * `connection_id` (`UUID`): Connection UUID
    * `transforms` (`[TransformInput!]`): Transforms to apply to the
      data source
    * `filters` (`FilterGroupInput`): Structured SQL filtering
      conditions to apply to query
    * `agent_span_filters` (`[AgentSpanFilterInput!]`): Filter by
      agent span fields (agent, workflow, task, span_name)
    """

    get_job_execution_history_logs = sgqlc.types.Field(
        sgqlc.types.list_of(JobExecutionHistoryLog),
        graphql_name="getJobExecutionHistoryLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_schedule_uuid",
                    sgqlc.types.Arg(String, graphql_name="jobScheduleUuid", default=None),
                ),
                ("monitor_uuid", sgqlc.types.Arg(String, graphql_name="monitorUuid", default=None)),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(String, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "table_monitor_uuid",
                    sgqlc.types.Arg(String, graphql_name="tableMonitorUuid", default=None),
                ),
                ("history_days", sgqlc.types.Arg(Int, graphql_name="historyDays", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                (
                    "bootstrap_only",
                    sgqlc.types.Arg(Boolean, graphql_name="bootstrapOnly", default=False),
                ),
                (
                    "include_snoozed",
                    sgqlc.types.Arg(Boolean, graphql_name="includeSnoozed", default=False),
                ),
                (
                    "include_data_collection_only",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="includeDataCollectionOnly", default=False
                    ),
                ),
                (
                    "include_bi_connections",
                    sgqlc.types.Arg(Boolean, graphql_name="includeBiConnections", default=False),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Get the job execution logs

    Arguments:

    * `job_schedule_uuid` (`String`): UUID of job schedule
    * `monitor_uuid` (`String`): UUID of monitor
    * `custom_rule_uuid` (`String`): (DEPRECATED) Use monitorUuid
      instead
    * `table_monitor_uuid` (`String`): (DEPRECATED) Use monitorUuid
      instead
    * `history_days` (`Int`): Number of days back
    * `limit` (`Int`): Max number of execution in the result
    * `bootstrap_only` (`Boolean`): True to return only job execution
      logs only to load bootstrap data (which don't follow the normal
      schedule). These jobs are not included in the normal job history
      because they are not associated with the monitor evaluation
      (default: `false`)
    * `include_snoozed` (`Boolean`): Include snoozed jobs (default:
      `false`)
    * `include_data_collection_only` (`Boolean`): Include data
      collection only jobs (default: `false`)
    * `include_bi_connections` (`Boolean`): Include BI connection
      schedules (default: `false`)
    """

    get_job_executions = sgqlc.types.Field(
        JobExecutionHistoryLogConnection,
        graphql_name="getJobExecutions",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_schedule_uuid",
                    sgqlc.types.Arg(String, graphql_name="jobScheduleUuid", default=None),
                ),
                ("monitor_uuid", sgqlc.types.Arg(String, graphql_name="monitorUuid", default=None)),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(String, graphql_name="customRuleUuid", default=None),
                ),
                (
                    "table_monitor_uuid",
                    sgqlc.types.Arg(String, graphql_name="tableMonitorUuid", default=None),
                ),
                ("history_days", sgqlc.types.Arg(Int, graphql_name="historyDays", default=None)),
                (
                    "include_snoozed",
                    sgqlc.types.Arg(Boolean, graphql_name="includeSnoozed", default=False),
                ),
                (
                    "include_data_collection_only",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="includeDataCollectionOnly", default=False
                    ),
                ),
                (
                    "include_bi_connections",
                    sgqlc.types.Arg(Boolean, graphql_name="includeBiConnections", default=False),
                ),
                (
                    "consolidating_job_uuid",
                    sgqlc.types.Arg(String, graphql_name="consolidatingJobUuid", default=None),
                ),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get the job execution logs

    Arguments:

    * `job_schedule_uuid` (`String`): UUID of job schedule
    * `monitor_uuid` (`String`): UUID of monitor
    * `custom_rule_uuid` (`String`): (DEPRECATED) Use monitorUuid
      instead
    * `table_monitor_uuid` (`String`): (DEPRECATED) Use monitorUuid
      instead
    * `history_days` (`Int`): Number of days back
    * `include_snoozed` (`Boolean`): Include snoozed jobs (default:
      `false`)
    * `include_data_collection_only` (`Boolean`): Include data
      collection only jobs (default: `false`)
    * `include_bi_connections` (`Boolean`): Include BI connection
      schedules (default: `false`)
    * `consolidating_job_uuid` (`String`): UUID of consolidating job
      to filter by
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_table_monitor = sgqlc.types.Field(
        "TableMonitor",
        graphql_name="getTableMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Get a table monitor

    Arguments:

    * `monitor_uuid` (`UUID!`)None
    """

    get_table_monitor_coverage = sgqlc.types.Field(
        "TableMonitorCoverage",
        graphql_name="getTableMonitorCoverage",
        args=sgqlc.types.ArgDict(
            (
                ("monitor_uuid", sgqlc.types.Arg(UUID, graphql_name="monitorUuid", default=None)),
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="monitorUuids",
                        default=None,
                    ),
                ),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "monitors_search",
                    sgqlc.types.Arg(String, graphql_name="monitorsSearch", default=None),
                ),
            )
        ),
    )
    """(experimental) Get table monitor coverage information

    Arguments:

    * `monitor_uuid` (`UUID`): UUID of the table monitor (for single
      monitor mode). Cannot be used with monitor_uuids.
    * `monitor_uuids` (`[UUID!]`): List of table monitor UUIDs (for
      bulk deletion mode). Cannot be used with monitor_uuid.
    * `search` (`String`): Search for tables by name, database, or
      schema (case-insensitive substring match)
    * `monitors_search` (`String`): Search for monitors by description
      (case-insensitive substring match)
    """

    get_monitors = sgqlc.types.Field(
        sgqlc.types.list_of("Monitor"),
        graphql_name="getMonitors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """List of monitors

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitors_count = sgqlc.types.Field(
        Int,
        graphql_name="getMonitorsCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """The number of monitors matching the filters

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_namespaces = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)),
        graphql_name="getMonitorNamespaces",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of monitor namespaces

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_warehouses = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(MonitorWarehouse)),
        graphql_name="getMonitorWarehouses",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of monitor warehouses

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(MonitorProject)),
        graphql_name="getMonitorProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of monitor projects

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_datasets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(MonitorDataset)),
        graphql_name="getMonitorDatasets",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of monitor datasets

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_tables = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(MonitorTable)),
        graphql_name="getMonitorTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of monitor tables

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_creators = sgqlc.types.Field(
        sgqlc.types.list_of("User"),
        graphql_name="getMonitorCreators",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of users who are monitor creators

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_updaters = sgqlc.types.Field(
        sgqlc.types.list_of("User"),
        graphql_name="getMonitorUpdaters",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitors),
                        graphql_name="monitorTypes",
                        default=None,
                    ),
                ),
                (
                    "status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(MonitorStatusType),
                        graphql_name="statusTypes",
                        default=None,
                    ),
                ),
                (
                    "consolidated_status_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ConsolidatedMonitorStatusType),
                        graphql_name="consolidatedStatusTypes",
                        default=None,
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="createdBy",
                        default=None,
                    ),
                ),
                (
                    "updated_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="updatedBy",
                        default=None,
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "sensitivities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sensitivities", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainIds",
                        default=None,
                    ),
                ),
                (
                    "uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="uuids", default=None
                    ),
                ),
                (
                    "created_by_filters",
                    sgqlc.types.Arg(
                        CreatedByFilters, graphql_name="createdByFilters", default=None
                    ),
                ),
                (
                    "labels",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labels", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UserDefinedMonitorSearchFields),
                        graphql_name="searchFields",
                        default=None,
                    ),
                ),
                (
                    "namespaces",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespaces", default=None
                    ),
                ),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "include_ootb_monitors",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbMonitors", default=False),
                ),
                (
                    "include_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="includeOotbReplacement", default=False),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "exclude_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeMcons", default=None
                    ),
                ),
                (
                    "alerted_only",
                    sgqlc.types.Arg(Boolean, graphql_name="alertedOnly", default=None),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput), graphql_name="tags", default=None
                    ),
                ),
                (
                    "asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="assetTags",
                        default=None,
                    ),
                ),
                (
                    "exclude_asset_tags",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairInput)),
                        graphql_name="excludeAssetTags",
                        default=None,
                    ),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="dataProductIds", default=None
                    ),
                ),
                (
                    "data_quality_dimensions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="dataQualityDimensions",
                        default=None,
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """(experimental) List of users who last modified the monitors

    Arguments:

    * `monitor_types` (`[UserDefinedMonitors]`): Type of monitors to
      filter by, default all
    * `status_types` (`[MonitorStatusType]`): Type of monitor status
      to filter by, default all
    * `consolidated_status_types` (`[ConsolidatedMonitorStatusType]`):
      Type of consolidated monitor status to filter by, default all
    * `description_field_or_table` (`[String]`): DEPRECATED
    * `created_by` (`[String!]`): Filter by creator using a list of
      user emails
    * `updated_by` (`[String!]`): Filter by updater using a list of
      user emails
    * `priorities` (`[String]`): Filter by priorities. It can include
      null to include monitors without a priority set
    * `sensitivities` (`[String]`): Filter by given sensitivities. Can
      include null to include monitors without a set sensitivity
    * `domain_id` (`UUID`): Domain uuid to filter by
    * `domain_ids` (`[UUID!]`): List of domain uuids to filter by
    * `uuids` (`[String]`): list of uuids of the monitors to filter by
    * `created_by_filters` (`CreatedByFilters`): Deprecated
    * `labels` (`[String]`): List of labels to filter by
    * `search` (`[String]`): Search criteria for filtering the
      monitors list
    * `search_fields` (`[UserDefinedMonitorSearchFields]`): Which
      fields to include during search
    * `namespaces` (`[String]`): filter by namespaces
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `include_ootb_monitors` (`Boolean`): If set to true, OOTB
      monitors will be returned. They will be the first few monitors
      in the first page of the results (default: `false`)
    * `include_ootb_replacement` (`Boolean`): If set to true and
      is_ootb_replacement is not specified or false, ootb_replacement
      monitors will be included in result (default: `false`)
    * `mcons` (`[String]`): Filter by warehouses, projects, datasets,
      or tables (MCON)
    * `exclude_mcons` (`[String]`): Exclude monitors associated with
      these warehouses, projects, datasets, or tables (MCON)
    * `alerted_only` (`Boolean`): EXPERIMENTAL. Filter monitors to
      only the ones that are breached.
    * `tags` (`[TagKeyValuePairInput]`): Filter by monitor tags. It
      can include null to include monitors without tags
    * `asset_tags` (`[TagKeyValuePairInput!]`): Filter by asset tags.
      Returns monitors with at least one linked table that has any of
      the provided tags
    * `exclude_asset_tags` (`[TagKeyValuePairInput!]`): Exclude
      monitors that have any linked table whose tags consist only of
      the provided tags. Tables with additional tags or no tags are
      included
    * `data_product_ids` (`[UUID]`): Filter by data product IDs
    * `data_quality_dimensions` (`[String]`): Filter by data quality
      dimensions
    * `order_by` (`String`): Field and direction to order monitors by
    * `limit` (`Int`): Number of monitors to return
    * `offset` (`Int`): From which monitor to return the next results
    """

    get_monitor_queries = sgqlc.types.Field(
        MonitorQueries,
        graphql_name="getMonitorQueries",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                ("bootstrap", sgqlc.types.Arg(Boolean, graphql_name="bootstrap", default=None)),
                ("format_sql", sgqlc.types.Arg(Boolean, graphql_name="formatSql", default=True)),
                (
                    "strip_metadata_comment",
                    sgqlc.types.Arg(Boolean, graphql_name="stripMetadataComment", default=False),
                ),
                ("all_queries", sgqlc.types.Arg(Boolean, graphql_name="allQueries", default=False)),
                (
                    "comparison_data_source_type",
                    sgqlc.types.Arg(
                        ComparisonDataSourceType,
                        graphql_name="comparisonDataSourceType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `monitor_uuid` (`UUID!`): UUID of monitor
    * `bootstrap` (`Boolean`): Return the bootstrap query
    * `format_sql` (`Boolean`): Pretty-print the SQL query (default:
      `true`)
    * `strip_metadata_comment` (`Boolean`): Strip the leading metadata
      comment (default: `false`)
    * `all_queries` (`Boolean`): Returns all queries that will be
      issued when the monitor is run. If false, only the first query
      will be returned. (default: `false`)
    * `comparison_data_source_type` (`ComparisonDataSourceType`):
      Source type for the monitor queries. This is used for comparison
      monitors to fetch queries for specific source type either
      `source` or `target`
    """

    test_monitor_queries = sgqlc.types.Field(
        MonitorQueriesResults,
        graphql_name="testMonitorQueries",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                ("all_queries", sgqlc.types.Arg(Boolean, graphql_name="allQueries", default=False)),
                (
                    "comparison_data_source_type",
                    sgqlc.types.Arg(
                        ComparisonDataSourceType,
                        graphql_name="comparisonDataSourceType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `monitor_uuid` (`UUID!`): UUID of monitor
    * `all_queries` (`Boolean`): Runs all the queries that will be
      issued when the monitor is run. If false, only the first query
      will be executed. (default: `false`)
    * `comparison_data_source_type` (`ComparisonDataSourceType`):
      Source type for the monitor queries. This is used for comparison
      monitors to fetch queries for specific source type either
      `source` or `target`
    """

    get_notification_audiences_for_table = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(NotificationAudience)),
        graphql_name="getNotificationAudiencesForTable",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Get notification audiences for table

    Arguments:

    * `mcon` (`String!`): MCON that specifies a table
    """

    get_monitor_comments = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorComment))),
        graphql_name="getMonitorComments",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get comments for a monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): UUID of the monitor
    """

    get_all_user_defined_monitors_v2 = sgqlc.types.Field(
        "UserDefinedMonitorConnectionV2Connection",
        graphql_name="getAllUserDefinedMonitorsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "user_defined_monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="userDefinedMonitorTypes",
                        default=None,
                    ),
                ),
                (
                    "created_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="createdBy", default=None
                    ),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                (
                    "entities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="entities", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "description_field_or_table",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="descriptionFieldOrTable",
                        default=None,
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "is_template_managed",
                    sgqlc.types.Arg(Boolean, graphql_name="isTemplateManaged", default=None),
                ),
                (
                    "is_ootb_replacement",
                    sgqlc.types.Arg(Boolean, graphql_name="isOotbReplacement", default=False),
                ),
                (
                    "namespace",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="namespace", default=None
                    ),
                ),
                (
                    "rule_name",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="ruleName", default=None
                    ),
                ),
                (
                    "search",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="search", default=None
                    ),
                ),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `user_defined_monitor_types` (`[String]`): Filter by monitor
      type
    * `created_by` (`[String]`): Filter by creator
    * `order_by` (`String`): Sorting of results
    * `entities` (`[String]`): Filter by associated entities (full
      table ID)
    * `mcons` (`[String]`): Filter by associated entities (MCON)
    * `description_field_or_table` (`[String]`): Match text on rule
      description, table, or field
    * `domain_id` (`UUID`): Filter by domain UUID
    * `is_template_managed` (`Boolean`): Filter monitors created by
      code
    * `is_ootb_replacement` (`Boolean`): Filter monitors which replace
      a default ootb detector (default: `false`)
    * `namespace` (`[String]`): Filter by namespace -> used in
      monitors created by code
    * `rule_name` (`[String]`): Filter by rule_name -> used in
      monitors created by code
    * `search` (`[String]`): Filter by: description, field, table,
      rule name, creator, namespace
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_all_user_defined_monitors = sgqlc.types.Field(
        "UserDefinedMonitorConnection",
        graphql_name="getAllUserDefinedMonitors",
        args=sgqlc.types.ArgDict(
            (
                (
                    "user_defined_monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="userDefinedMonitorTypes",
                        default=None,
                    ),
                ),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `user_defined_monitor_types` (`[String]`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_custom_rule = sgqlc.types.Field(
        "CustomRule",
        graphql_name="getCustomRule",
        args=sgqlc.types.ArgDict(
            (
                ("rule_id", sgqlc.types.Arg(UUID, graphql_name="ruleId", default=None)),
                (
                    "description_contains",
                    sgqlc.types.Arg(String, graphql_name="descriptionContains", default=None),
                ),
                (
                    "custom_sql_contains",
                    sgqlc.types.Arg(String, graphql_name="customSqlContains", default=None),
                ),
            )
        ),
    )
    """Get a custom rule

    Arguments:

    * `rule_id` (`UUID`): Rule id
    * `description_contains` (`String`): String to completely or
      partially match the rule description, case-insensitive
    * `custom_sql_contains` (`String`): String to completely or
      partially match the rule SQL, case-insensitive
    """

    get_custom_rules = sgqlc.types.Field(
        CustomRuleConnection,
        graphql_name="getCustomRules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "entity_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="entityMcons", default=None
                    ),
                ),
                (
                    "metadata_keys",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="metadataKeys", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "rule_type",
                    sgqlc.types.Arg(CustomRuleModelRuleType, graphql_name="ruleType", default=None),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `entity_mcons` (`[String]`): Return rules associated with any of
      these table MCONs
    * `metadata_keys` (`[String]`): Return rules with all these keys
      in their metadata
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `rule_type` (`CustomRuleModelRuleType`)None
    * `warehouse_uuid` (`UUID`)None
    """

    get_generated_rules = sgqlc.types.Field(
        sgqlc.types.list_of("CustomRule"),
        graphql_name="getGeneratedRules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "generated_by_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="generatedByUuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `generated_by_uuid` (`UUID`): Parent CustomRule UUID
    """

    get_circuit_breaker_rule_state = sgqlc.types.Field(
        CircuitBreakerState,
        graphql_name="getCircuitBreakerRuleState",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_execution_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="jobExecutionUuid", default=None
                    ),
                ),
            )
        ),
    )
    """State for the circuit breaker rule job execution

    Arguments:

    * `job_execution_uuid` (`UUID!`): The UUID of the job execution to
      get the state for
    """

    get_circuit_breaker_rule_state_v2 = sgqlc.types.Field(
        sgqlc.types.list_of(CircuitBreakerState),
        graphql_name="getCircuitBreakerRuleStateV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_execution_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="jobExecutionUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """State for the circuit breaker rule job executions

    Arguments:

    * `job_execution_uuids` (`[UUID]!`): The UUIDs of the job
      executions to get the state for
    """

    get_run_sql_rule_state = sgqlc.types.Field(
        sgqlc.types.list_of(CircuitBreakerState),
        graphql_name="getRunSqlRuleState",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_execution_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="jobExecutionUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """State for the sql rule job executions

    Arguments:

    * `job_execution_uuids` (`[UUID]!`): The UUID of the job execution
      to get the state for
    """

    get_tables_for_sql = sgqlc.types.Field(
        sgqlc.types.list_of("SqlQueryTable"),
        graphql_name="getTablesForSql",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                (
                    "custom_sql",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="customSql", default=None
                    ),
                ),
                (
                    "custom_sampling_sql",
                    sgqlc.types.Arg(String, graphql_name="customSamplingSql", default=None),
                ),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
            )
        ),
    )
    """The full table ids calculated from the sql query

    Arguments:

    * `warehouse_uuid` (`UUID!`): Warehouse UUID.
    * `custom_sql` (`String!`): Custom SQL query to run
    * `custom_sampling_sql` (`String`): Custom sampling SQL query to
      run on breach
    * `variables` (`JSONString`): Possible variable values for SQL
      query
    """

    get_notification_settings_for_rules_with = sgqlc.types.Field(
        sgqlc.types.list_of(AccountNotificationSetting),
        graphql_name="getNotificationSettingsForRulesWith",
        args=sgqlc.types.ArgDict(
            (
                (
                    "rule_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="ruleType", default=None
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                (
                    "full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fullTableIds", default=None
                    ),
                ),
                (
                    "label_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labelNames", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. The notification settings that will be
    used in a rule with the specified data

    Arguments:

    * `rule_type` (`String!`): Rule type.
    * `warehouse_uuid` (`UUID!`): Warehouse UUID.
    * `full_table_ids` (`[String]`): Full table ids.
    * `label_names` (`[String]`): Monitor labels.
    """

    get_field_metric_query = sgqlc.types.Field(
        FieldMetricQuery,
        graphql_name="getFieldMetricQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "field_metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(FieldMetricInput),
                        graphql_name="fieldMetric",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """DEPRECATED: Build field quality rule query from parameters

    Arguments:

    * `field_metric` (`FieldMetricInput!`): field quality rule query
      parameters
    """

    get_field_query = sgqlc.types.Field(
        FieldQuery,
        graphql_name="getFieldQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "field_query_parameters",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(FieldQueryParametersInput),
                        graphql_name="fieldQueryParameters",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Build field quality rule SQL query from parameters

    Arguments:

    * `field_query_parameters` (`FieldQueryParametersInput!`): Field
      quality rule query parameters
    """

    get_query_template = sgqlc.types.Field(
        "QueryTemplateOutput",
        graphql_name="getQueryTemplate",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query_template_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryTemplateId", default=None
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
                (
                    "variable_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(QueryTemplateVariableValueInput)),
                        graphql_name="variableValues",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Gets a query template

    Arguments:

    * `query_template_id` (`String!`): ID for the template used to
      generate this query
    * `warehouse_uuid` (`UUID`): UUID for the warehouse where the run
      will be executed
    * `variable_values` (`[QueryTemplateVariableValueInput!]`): Values
      for the template variables. If not provided, the template source
      will be returned
    """

    get_custom_rule_execution_analytics = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(CustomRuleExecutionAnalytics))
        ),
        graphql_name="getCustomRuleExecutionAnalytics",
        args=sgqlc.types.ArgDict(
            (
                (
                    "rule_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="ruleId", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("timezone", sgqlc.types.Arg(String, graphql_name="timezone", default=None)),
                (
                    "group_by",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(PeriodGrouping), graphql_name="groupBy", default=None
                    ),
                ),
            )
        ),
    )
    """Return analytics for the executions of the custom rules

    Arguments:

    * `rule_id` (`UUID!`): Rule id
    * `start_time` (`DateTime!`): Beginning of time range to calculate
      the execution analytics
    * `end_time` (`DateTime`): End of time range to calculate the
      execution analytics
    * `timezone` (`String`): Timezone to apply when grouping by date
    * `group_by` (`PeriodGrouping!`): Time buckets to group time-bound
      analytics by.
    """

    get_insights = sgqlc.types.Field(sgqlc.types.list_of(Insight), graphql_name="getInsights")
    """List of available insights"""

    get_insight = sgqlc.types.Field(
        Insight,
        graphql_name="getInsight",
        args=sgqlc.types.ArgDict(
            (
                (
                    "insight_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="insightName", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `insight_name` (`String!`): Name (id) of insight to fetch
    """

    get_reports = sgqlc.types.Field(
        sgqlc.types.list_of("Report"),
        graphql_name="getReports",
        args=sgqlc.types.ArgDict(
            (
                (
                    "insight_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="insightName", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `insight_name` (`String!`): Name (id) of insight for which to
      fetch reports
    """

    get_report_url = sgqlc.types.Field(
        "ResponseURL",
        graphql_name="getReportUrl",
        args=sgqlc.types.ArgDict(
            (
                (
                    "insight_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="insightName", default=None
                    ),
                ),
                (
                    "report_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="reportName", default=None
                    ),
                ),
                (
                    "created_before",
                    sgqlc.types.Arg(DateTime, graphql_name="createdBefore", default=None),
                ),
            )
        ),
    )
    """Name (id) of insight to fetch

    Arguments:

    * `insight_name` (`String!`)None
    * `report_name` (`String!`): Name of report to fetch
    * `created_before` (`DateTime`): Version of the report created
      before specific date
    """

    get_lineage_node_block_pattern = sgqlc.types.Field(
        LineageNodeBlockPattern,
        graphql_name="getLineageNodeBlockPattern",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="uuid", default=None
                    ),
                ),
            )
        ),
    )
    """Retrieve a node block pattern

    Arguments:

    * `uuid` (`String!`): Node block pattern id
    """

    get_lineage_node_block_patterns = sgqlc.types.Field(
        sgqlc.types.list_of(LineageNodeBlockPattern),
        graphql_name="getLineageNodeBlockPatterns",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="resourceId", default=None
                    ),
                ),
            )
        ),
    )
    """Retrieve a list of node block patterns

    Arguments:

    * `resource_id` (`String!`): Resource id of the resources
    """

    get_lineage_node_replacement_rule = sgqlc.types.Field(
        LineageNodeReplacementRule,
        graphql_name="getLineageNodeReplacementRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Retrieve a node replacement rule

    Arguments:

    * `uuid` (`UUID!`): Replacement rule UUID
    """

    get_lineage_node_replacement_rules = sgqlc.types.Field(
        sgqlc.types.list_of(LineageNodeReplacementRule),
        graphql_name="getLineageNodeReplacementRules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
            )
        ),
    )
    """Retrieve a list of node replacement rules

    Arguments:

    * `resource_id` (`UUID!`): Resource id of the resources
    """

    get_lineage_node_collapsing_rules = sgqlc.types.Field(
        sgqlc.types.list_of(LineageNodeCollapsingRule), graphql_name="getLineageNodeCollapsingRules"
    )
    """Retrieve a list of node collapsing rules"""

    get_lineage_node_collapsing_rule = sgqlc.types.Field(
        LineageNodeCollapsingRule,
        graphql_name="getLineageNodeCollapsingRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Retrieve a node collapsing rule

    Arguments:

    * `uuid` (`UUID!`): Collapsing rule UUID
    """

    simulate_lineage_node_replacement_rule = sgqlc.types.Field(
        sgqlc.types.list_of(LineageNodeReplacementRuleResult),
        graphql_name="simulateLineageNodeReplacementRule",
        args=sgqlc.types.ArgDict(
            (
                (
                    "pattern",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="pattern", default=None
                    ),
                ),
                (
                    "replacement",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="replacement", default=None
                    ),
                ),
                (
                    "test_input_strings",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="testInputStrings",
                        default=None,
                    ),
                ),
                (
                    "case_insensitive",
                    sgqlc.types.Arg(Boolean, graphql_name="caseInsensitive", default=None),
                ),
            )
        ),
    )
    """Simulate a replacement pattern

    Arguments:

    * `pattern` (`String!`): Input regex pattern
    * `replacement` (`String!`): Replacement pattern
    * `test_input_strings` (`[String]!`): Input to test
    * `case_insensitive` (`Boolean`): Case sensitivity of the pattern
      matching
    """

    get_catalog_object_metadata = sgqlc.types.Field(
        CatalogObjectMetadataConnection,
        graphql_name="getCatalogObjectMetadata",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `mcon` (`String`)None
    """

    get_catalog_nav_level_nodes = sgqlc.types.Field(
        CatalogNavResults,
        graphql_name="getCatalogNavLevelNodes",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("parent_mcon", sgqlc.types.Arg(String, graphql_name="parentMcon", default=None)),
                (
                    "object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="objectTypes", default=None
                    ),
                ),
                (
                    "exclude_object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeObjectTypes", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """Get nodes for navigating the catalog by type and hierarchy.

    Arguments:

    * `mcon` (`String`): Filter by mcon, returns this single object
    * `parent_mcon` (`String`): Only include children of this catalog
      object. If not given, will get top-level objects.
    * `object_types` (`[String]`): Only include objects of these
      types.
    * `exclude_object_types` (`[String]`): Exclude objects of these
      types.
    * `domain_id` (`UUID`): Only include objects in this domain or its
      hierarchy.
    * `offset` (`Int`): Starting node index for current page.
    * `limit` (`Int`): Max nodes to get for page.
    """

    get_catalog_nav_grouped_nodes = sgqlc.types.Field(
        sgqlc.types.list_of(CatalogNavResults),
        graphql_name="getCatalogNavGroupedNodes",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("parent_mcon", sgqlc.types.Arg(String, graphql_name="parentMcon", default=None)),
                (
                    "object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="objectTypes", default=None
                    ),
                ),
                (
                    "exclude_object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeObjectTypes", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """Get nodes for navigating the catalog by type and hierarchy.

    Arguments:

    * `mcon` (`String`): Filter by mcon, returns this single object
    * `parent_mcon` (`String`): Only include children of this catalog
      object. If not given, will get top-level objects.
    * `object_types` (`[String]`): Only include objects of these
      types.
    * `exclude_object_types` (`[String]`): Exclude objects of these
      types.
    * `domain_id` (`UUID`): Only include objects in this domain or its
      hierarchy.
    * `offset` (`Int`): Starting node index for current page.
    * `limit` (`Int`): Max nodes to get for page.
    """

    get_object_properties = sgqlc.types.Field(
        ObjectPropertyConnection,
        graphql_name="getObjectProperties",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("mcon_id", sgqlc.types.Arg(String, graphql_name="mconId", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `mcon_id` (`String`)None
    """

    get_object_property_name_values = sgqlc.types.Field(
        PropertyNameValues,
        graphql_name="getObjectPropertyNameValues",
        args=sgqlc.types.ArgDict(
            (
                (
                    "search_string",
                    sgqlc.types.Arg(String, graphql_name="searchString", default=None),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=100)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                (
                    "exclude_string",
                    sgqlc.types.Arg(String, graphql_name="excludeString", default=None),
                ),
                (
                    "search_source_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="searchSourceTypes", default=None
                    ),
                ),
                (
                    "exclude_source_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeSourceTypes", default=None
                    ),
                ),
            )
        ),
    )
    """Return all unique property names/values for an account

    Arguments:

    * `search_string` (`String`)None
    * `first` (`Int`)None (default: `100`)
    * `offset` (`Int`)None (default: `0`)
    * `exclude_string` (`String`): Filters out properties that
      contains the exclude string in the property key.
    * `search_source_types` (`[String]`): Only return properties of
      these types
    * `exclude_source_types` (`[String]`): Filter out properties of
      these types
    """

    get_object_property_names = sgqlc.types.Field(
        PropertyNames,
        graphql_name="getObjectPropertyNames",
        args=sgqlc.types.ArgDict(
            (
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=100)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                (
                    "search_string",
                    sgqlc.types.Arg(String, graphql_name="searchString", default=None),
                ),
            )
        ),
    )
    """Return all unique property names for an account

    Arguments:

    * `limit` (`Int`)None (default: `100`)
    * `offset` (`Int`)None (default: `0`)
    * `search_string` (`String`): Filter property names by search
      string
    """

    get_object_property_values = sgqlc.types.Field(
        PropertyValues,
        graphql_name="getObjectPropertyValues",
        args=sgqlc.types.ArgDict(
            (
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=100)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                (
                    "property_name",
                    sgqlc.types.Arg(String, graphql_name="propertyName", default=None),
                ),
                (
                    "search_string",
                    sgqlc.types.Arg(String, graphql_name="searchString", default=None),
                ),
            )
        ),
    )
    """Return all unique property values for an account

    Arguments:

    * `limit` (`Int`)None (default: `100`)
    * `offset` (`Int`)None (default: `0`)
    * `property_name` (`String`): Filter by property name
    * `search_string` (`String`): Filter property values by search
      string
    """

    get_monitor_labels = sgqlc.types.Field(
        sgqlc.types.list_of(MonitorLabelObject), graphql_name="getMonitorLabels"
    )
    """Get monitor labels"""

    monitor_labels = sgqlc.types.Field(
        sgqlc.types.list_of(MonitorLabel), graphql_name="monitorLabels"
    )
    """Get monitor labels"""

    get_account_monitor_labels = sgqlc.types.Field(
        sgqlc.types.list_of(MonitorLabelObject), graphql_name="getAccountMonitorLabels"
    )
    """Get monitor labels"""

    get_custom_sql_templates = sgqlc.types.Field(
        CustomSQLTemplateConnection,
        graphql_name="getCustomSqlTemplates",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query_result_type_filter",
                    sgqlc.types.Arg(
                        QueryResultType, graphql_name="queryResultTypeFilter", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("sql_template", sgqlc.types.Arg(String, graphql_name="sqlTemplate", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        CustomSQLTemplateModelQueryResultType,
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get all active Custom SQL Templates

    Arguments:

    * `query_result_type_filter` (`QueryResultType`):
      CustomSQLTemplate's query result type can be set to
      SINGLE_NUMERIC, ROW_COUNT and LABELED_NUMERICS. The filter is
      None then all templates are returned
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `name` (`String`)None
    * `description` (`String`)None
    * `sql_template` (`String`)None
    * `dialect` (`String`)None
    * `query_result_type`
      (`CustomSQLTemplateModelQueryResultType`)None
    """

    get_active_monitors = sgqlc.types.Field(
        MetricMonitoringConnection,
        graphql_name="getActiveMonitors",
        args=sgqlc.types.ArgDict(
            (
                ("entities", sgqlc.types.Arg(String, graphql_name="entities", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Get all active custom monitors (one of Field Health, Distribution
    Tracking, or JSON Schema). Does not return custom rules.

    Arguments:

    * `entities` (`String`): Filter by full table id or mcon
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    get_monitor_summary = sgqlc.types.Field(
        MonitorSummary,
        graphql_name="getMonitorSummary",
        args=sgqlc.types.ArgDict(
            (
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Arguments:

    * `resource_id` (`UUID`): Filter by resource UUID
    * `domain_id` (`UUID`): Filter by domain UUID
    """

    get_monitors_by_type = sgqlc.types.Field(
        MetricMonitoringConnection,
        graphql_name="getMonitorsByType",
        args=sgqlc.types.ArgDict(
            (
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "monitor_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="monitorTypes", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Retrieve information on custom monitors of a given type (one of
    Field Health, Distribution Tracking, or JSON Schema). Does not
    return custom rules.

    Arguments:

    * `monitor_type` (`String`)None
    * `monitor_types` (`[String]`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    get_monitor = sgqlc.types.Field(
        "MetricMonitoring",
        graphql_name="getMonitor",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
            )
        ),
    )
    """Retrieve information about a custom monitor (one of Field Health,
    Distribution Tracking, or JSON Schema). Does not return custom
    rules.

    Arguments:

    * `uuid` (`UUID`): Get monitor by UUID
    * `resource_id` (`UUID`): Specify the resource uuid (e.g.
      warehouse the table is contained in) when using a fullTableId
    * `full_table_id` (`String`): Deprecated - use mcon. Ignored if
      mcon is present
    * `mcon` (`String`): Get monitor by mcon
    * `monitor_type` (`String`): Specify the monitor type. Required
      when using an mcon or full table id
    """

    get_monitor_configuration = sgqlc.types.Field(
        MonitorConfiguration,
        graphql_name="getMonitorConfiguration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "configuration_data",
                    sgqlc.types.Arg(
                        MonitorConfigurationInput, graphql_name="configurationData", default=None
                    ),
                ),
            )
        ),
    )
    """The time axis data for the monitor

    Arguments:

    * `configuration_data` (`MonitorConfigurationInput`)
    """

    get_monitor_scheduling_configuration = sgqlc.types.Field(
        MonitorSchedulingConfiguration,
        graphql_name="getMonitorSchedulingConfiguration",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """The scheduling configuration for the monitor

    Arguments:

    * `mcon` (`String!`): mcon for table to fetch scheduling for
    """

    get_time_axis_sql_expressions = sgqlc.types.Field(
        sgqlc.types.list_of("SqlExpression"), graphql_name="getTimeAxisSqlExpressions"
    )
    """The SQL expressions used in time axis in monitors for the account"""

    get_notification_settings_for_monitors_with = sgqlc.types.Field(
        sgqlc.types.list_of(AccountNotificationSetting),
        graphql_name="getNotificationSettingsForMonitorsWith",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="monitorType", default=None
                    ),
                ),
                (
                    "label_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="labelNames", default=None
                    ),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. The notification settings that will be
    used in a monitor with the specified data

    Arguments:

    * `monitor_type` (`String!`): Monitor type.
    * `label_names` (`[String]`): Label names.
    * `mcon` (`String`): MCON of the table associated with the
      monitor.
    """

    get_custom_metric_test_query = sgqlc.types.Field(
        CustomMetricQuery,
        graphql_name="getCustomMetricTestQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_metric_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CustomMetricQueryInput),
                        graphql_name="customMetricQuery",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Build a query to test a custom metric

    Arguments:

    * `custom_metric_query` (`CustomMetricQueryInput!`): Custom metric
      query parameters
    """

    run_custom_metric_test_query = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="runCustomMetricTestQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "custom_metric_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(CustomMetricQueryInput),
                        graphql_name="customMetricQuery",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Run a query to test a custom metric

    Arguments:

    * `custom_metric_query` (`CustomMetricQueryInput!`): Custom metric
      query parameters
    """

    get_segment_count_query = sgqlc.types.Field(
        "SegmentCountQuery",
        graphql_name="getSegmentCountQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "segment_count_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SegmentCountQueryInput),
                        graphql_name="segmentCountQuery",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Build a query to collect segment count

    Arguments:

    * `segment_count_query` (`SegmentCountQueryInput!`): Segment count
      query parameters
    """

    run_segment_count_query = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="runSegmentCountQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "segment_count_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(SegmentCountQueryInput),
                        graphql_name="segmentCountQuery",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Run a query to collect segment count

    Arguments:

    * `segment_count_query` (`SegmentCountQueryInput!`): Segment count
      query parameters
    """

    evaluate_comparison_monitor_alert_conditions = sgqlc.types.Field(
        ComparisonEvaluationResults,
        graphql_name="evaluateComparisonMonitorAlertConditions",
        args=sgqlc.types.ArgDict(
            (
                (
                    "source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ExtendedDataSourceInput),
                        graphql_name="source",
                        default=None,
                    ),
                ),
                (
                    "target",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ExtendedDataSourceInput),
                        graphql_name="target",
                        default=None,
                    ),
                ),
                (
                    "alert_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(ComparisonAlertConditionInput))
                        ),
                        graphql_name="alertConditions",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Evaluates the provided comparison monitor alert
    conditions

    Arguments:

    * `source` (`ExtendedDataSourceInput!`): source for comparison
      monitor
    * `target` (`ExtendedDataSourceInput!`): target for comparison
      monitor
    * `alert_conditions` (`[ComparisonAlertConditionInput!]!`):
      Comparison monitor Alert conditions
    """

    evaluate_comparisons = sgqlc.types.Field(
        ComparisonEvaluationResults,
        graphql_name="evaluateComparisons",
        args=sgqlc.types.ArgDict(
            (
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "comparisons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparisonInput)),
                        graphql_name="comparisons",
                        default=None,
                    ),
                ),
                (
                    "validate_custom_sql",
                    sgqlc.types.Arg(Boolean, graphql_name="validateCustomSql", default=True),
                ),
                (
                    "high_segment_count",
                    sgqlc.types.Arg(Boolean, graphql_name="highSegmentCount", default=False),
                ),
                ("aggregate_by", sgqlc.types.Arg(String, graphql_name="aggregateBy", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Evaluates the provided metric monitor
    comparisons

    Arguments:

    * `connection_id` (`UUID`): Connection UUID
    * `dw_id` (`UUID`): Warehouse UUID
    * `data_source` (`DataSourceUnionInput!`): The data source
    * `comparisons` (`[CustomRuleComparisonInput]!`): Metric monitor
      comparisons.
    * `validate_custom_sql` (`Boolean`): Whether to validate the
      custom and generated SQL by running it against the data
      warehouse (default: `true`)
    * `high_segment_count` (`Boolean`): Flag to apply additional
      limits which increase the supported segment count (default:
      `false`)
    * `aggregate_by` (`String`): The time aggregation for the monitor,
      if any. Determines the maximum number of segments.
    """

    evaluate_alert_conditions = sgqlc.types.Field(
        ComparisonEvaluationResults,
        graphql_name="evaluateAlertConditions",
        args=sgqlc.types.ArgDict(
            (
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                (
                    "alert_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(
                            sgqlc.types.list_of(sgqlc.types.non_null(MetricAlertConditionInput))
                        ),
                        graphql_name="alertConditions",
                        default=None,
                    ),
                ),
                (
                    "validate_custom_sql",
                    sgqlc.types.Arg(Boolean, graphql_name="validateCustomSql", default=True),
                ),
                (
                    "high_segment_count",
                    sgqlc.types.Arg(Boolean, graphql_name="highSegmentCount", default=False),
                ),
                ("aggregate_by", sgqlc.types.Arg(String, graphql_name="aggregateBy", default=None)),
            )
        ),
    )
    """(experimental) Evaluates the provided metric monitor alert
    conditions

    Arguments:

    * `connection_id` (`UUID`): Connection UUID
    * `dw_id` (`UUID`): Warehouse UUID
    * `data_source` (`DataSourceUnionInput!`): The data source
    * `alert_conditions` (`[MetricAlertConditionInput!]!`): Metric
      monitor alert conditions
    * `validate_custom_sql` (`Boolean`): Whether to validate the
      custom and generated SQL by running it against the data
      warehouse (default: `true`)
    * `high_segment_count` (`Boolean`): Flag to apply additional
      limits which increase the supported segment count (default:
      `false`)
    * `aggregate_by` (`String`): The time aggregation for the monitor,
      if any. Determines the maximum number of segments.
    """

    get_delta_logs = sgqlc.types.Field(
        DeltaLogConnection,
        graphql_name="getDeltaLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
            )
        ),
    )
    """Get Delta logs for the provided table. Due to Databricks'
    limitations, this query field only supports forwards pagination
    with first and after, but not backwards with last and before.

    Arguments:

    * `mcon` (`String!`): MCON for table to get delta logs for
    * `start_time` (`DateTime`): Beginning of time window to filter
      to. Defaults to the 10 most recent delta logs.
    * `end_time` (`DateTime`): End of time window to filter to.
      Defaults to the 10 most recent delta logs.
    * `first` (`Int`): The number of items to return (default: 10).
    * `after` (`String`): Cursor of the last item on the previous page
    """

    get_job_schedules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(DataCollectorScheduleInfo))),
        graphql_name="getJobSchedules",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="resourceUuid", default=None
                    ),
                ),
                (
                    "connection_uuid",
                    sgqlc.types.Arg(String, graphql_name="connectionUuid", default=None),
                ),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(InternalJobType)),
                        graphql_name="jobTypes",
                        default=None,
                    ),
                ),
                (
                    "schedule_type",
                    sgqlc.types.Arg(String, graphql_name="scheduleType", default=None),
                ),
                (
                    "include_deleted",
                    sgqlc.types.Arg(Boolean, graphql_name="includeDeleted", default=False),
                ),
            )
        ),
    )
    """(experimental) Get data collector schedules for a resource
    (warehouse, BI tool, etc.)

    Arguments:

    * `resource_uuid` (`String!`): Resource UUID (warehouse, BI
      container, etc.)
    * `connection_uuid` (`String`): Connection UUID (optional, filters
      to specific connection)
    * `job_types` (`[InternalJobType!]`): List of job types to filter
      by (e.g., METADATA, QUERY_LOGS)
    * `schedule_type` (`String`): DEPRECATED: Schedule type filtering
      is no longer supported.
    * `include_deleted` (`Boolean`): Include deleted schedules
      (default: `false`)
    """

    get_collector_job_limits = sgqlc.types.Field(
        JSONString,
        graphql_name="getCollectorJobLimits",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dc_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dcId", default=None),
                ),
                (
                    "job_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(InternalJobType), graphql_name="jobType", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(ConnectionTypeEnum),
                        graphql_name="connectionType",
                        default=None,
                    ),
                ),
                (
                    "connection_subtype",
                    sgqlc.types.Arg(
                        ConnectionSubtypeEnum, graphql_name="connectionSubtype", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get default job limits for a specific job type and
    connection type.

    Arguments:

    * `dc_id` (`UUID!`): The UUID identifying the data collector.
    * `job_type` (`InternalJobType!`): The type of job (e.g.,
      METADATA, QUERY_LOGS, BI_REPORTS).
    * `connection_type` (`ConnectionTypeEnum!`): Connection type
      (e.g., snowflake, tableau).
    * `connection_subtype` (`ConnectionSubtypeEnum`): Optional, for
      transactional DB subtype (e.g., sap-hana). When provided, it
      will be used instead of connection_type.
    """

    get_data_assets_dashboard = sgqlc.types.Field(
        DataAssetDashboard,
        graphql_name="getDataAssetsDashboard",
        args=sgqlc.types.ArgDict(
            (("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),)
        ),
    )
    """Dashboard counts for monitored data assets

    Arguments:

    * `domain_uuid` (`UUID`): The domain id to filter by
    """

    get_incident_dashboard_data = sgqlc.types.Field(
        IncidentDashboardData,
        graphql_name="getIncidentDashboardData",
        args=sgqlc.types.ArgDict(
            (
                ("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),
                (
                    "lookback_weeks",
                    sgqlc.types.Arg(Int, graphql_name="lookbackWeeks", default=None),
                ),
            )
        ),
    )
    """Dashboard counts for incidents occurring over specified weeks

    Arguments:

    * `domain_uuid` (`UUID`): The domain id to filter by
    * `lookback_weeks` (`Int`): The number of weeks to aggregate data
      over
    """

    get_incident_data_weekly = sgqlc.types.Field(
        IncidentWeeklyDataDashboard,
        graphql_name="getIncidentDataWeekly",
        args=sgqlc.types.ArgDict(
            (
                (
                    "group_by",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(IncidentGroupBy), graphql_name="groupBy", default=None
                    ),
                ),
                ("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),
                (
                    "lookback_weeks",
                    sgqlc.types.Arg(Int, graphql_name="lookbackWeeks", default=None),
                ),
            )
        ),
    )
    """Dashboard counts for incidents occurring over specified weeks

    Arguments:

    * `group_by` (`IncidentGroupBy!`): The value to group the
      incidents by
    * `domain_uuid` (`UUID`): The domain id to filter by
    * `lookback_weeks` (`Int`): The number of weeks to aggregate data
      over
    """

    get_alert_data_weekly = sgqlc.types.Field(
        AlertWeeklyDataDashboard,
        graphql_name="getAlertDataWeekly",
        args=sgqlc.types.ArgDict(
            (
                (
                    "group_by",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AlertGroupBy), graphql_name="groupBy", default=None
                    ),
                ),
                ("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),
                (
                    "lookback_weeks",
                    sgqlc.types.Arg(Int, graphql_name="lookbackWeeks", default=None),
                ),
            )
        ),
    )
    """Dashboard counts for alerts occurring over specified weeks

    Arguments:

    * `group_by` (`AlertGroupBy!`): The value to group the alerts by
    * `domain_uuid` (`UUID`): The domain id to filter by
    * `lookback_weeks` (`Int`): The number of weeks to aggregate data
      over
    """

    get_monitor_dashboard_data = sgqlc.types.Field(
        MonitorDashboardData,
        graphql_name="getMonitorDashboardData",
        args=sgqlc.types.ArgDict(
            (("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),)
        ),
    )
    """Dashboard counts for monitors

    Arguments:

    * `domain_uuid` (`UUID`): The domain id to filter by
    """

    get_blast_radius_direct_users_v2 = sgqlc.types.Field(
        PaginateUsersBlastRadius2,
        graphql_name="getBlastRadiusDirectUsersV2",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                (
                    "lookback",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LookbackRange), graphql_name="lookback", default=None
                    ),
                ),
                ("after_key", sgqlc.types.Arg(String, graphql_name="afterKey", default=None)),
                ("size", sgqlc.types.Arg(Int, graphql_name="size", default=20)),
            )
        ),
    )
    """User information for direct blast radius of an incident

    Arguments:

    * `incident_id` (`UUID`): The incident UUID. Deprecated, use
      alertId instead
    * `alert_id` (`UUID`): The alert UUID
    * `lookback` (`LookbackRange!`): The lookback period for the blast
      radius [ONE_HOUR, TWELVE_HOUR, ONE_DAY, SEVEN_DAY]
    * `after_key` (`String`): The key for pagination
    * `size` (`Int`): The max number of results to fetch (default:
      `20`)
    """

    get_incident_tables = sgqlc.types.Field(
        IncidentTableMcons,
        graphql_name="getIncidentTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. The MCONS directly impacted by the
    incident

    Arguments:

    * `incident_id` (`UUID!`): The incident UUID
    """

    get_incident_warehouse_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"),
        graphql_name="getIncidentWarehouseTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. The Warehouse Tables associated with an
    incident

    Arguments:

    * `incident_id` (`UUID!`): The incident UUID
    """

    get_alert_warehouse_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"),
        graphql_name="getAlertWarehouseTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) The Warehouse Tables associated with an alert

    Arguments:

    * `alert_id` (`UUID!`): The alert UUID
    """

    get_schema_changes = sgqlc.types.Field(
        "SchemaChangeConnection",
        graphql_name="getSchemaChanges",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get schema changes for a specific table

    Arguments:

    * `mcon` (`String!`): Get changes for the given MCON
    * `start_time` (`DateTime`): Filter by the start time
    * `end_time` (`DateTime`): Filter by the end time
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_event_groups = sgqlc.types.Field(
        sgqlc.types.list_of(EventGroup),
        graphql_name="getEventGroups",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get event groups, excluding metric events

    Arguments:

    * `alert_id` (`UUID!`): Filter by alert (grouping of related
      events)
    """

    get_metric_event_groups = sgqlc.types.Field(
        sgqlc.types.list_of(MetricEventGroup),
        graphql_name="getMetricEventGroups",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get event groups, including only metric events

    Arguments:

    * `alert_id` (`UUID!`): Filter by alert (grouping of related
      events)
    """

    get_events = sgqlc.types.Field(
        EventConnection,
        graphql_name="getEvents",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("event_type", sgqlc.types.Arg(String, graphql_name="eventType", default=None)),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventTypes", default=None
                    ),
                ),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                (
                    "tables_older_than_days",
                    sgqlc.types.Arg(Int, graphql_name="tablesOlderThanDays", default=None),
                ),
                (
                    "event_states",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventStates", default=None
                    ),
                ),
                (
                    "exclude_state",
                    sgqlc.types.Arg(String, graphql_name="excludeState", default=None),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                (
                    "include_timeline_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeTimelineEvents", default=None),
                ),
                (
                    "include_anomaly_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeAnomalyEvents", default=None),
                ),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=None)),
                ("monitor_id", sgqlc.types.Arg(UUID, graphql_name="monitorId", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get events (i.e. anomalies, changes, etc.) in my account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `full_table_id` (`String`): Filter by the full table id (e.g.
      project:dataset.table)
    * `event_type` (`String`): Filter by the type of event
    * `event_types` (`[String]`): Filter by a list of types
    * `dataset` (`String`): Filter by the dataset
    * `tables_older_than_days` (`Int`): Filter for events based on
      table age
    * `event_states` (`[String]`): Filter by a list of states
    * `exclude_state` (`String`): Exclude a specific state
    * `start_time` (`DateTime`): Filter for events newer than this
    * `end_time` (`DateTime`): Filter for events older than this
    * `incident_id` (`UUID`): Filter by incident (grouping of related
      events). Deprecated, use alertId instead
    * `alert_id` (`UUID`): Filter by alert (grouping of related
      events)
    * `include_timeline_events` (`Boolean`): Flag that decides whether
      to include incident timeline related events. If event_types
      specified, this will be ignored.
    * `include_anomaly_events` (`Boolean`): Flag that decides whether
      to include anomaly timeline related events. If event_types
      specified, this will be ignored
    * `desc_order` (`Boolean`): Returns events in descending order of
      create_time
    * `monitor_id` (`UUID`): Filter by the UUID of the monitor or rule
      that generated the event
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_events_for_incidents = sgqlc.types.Field(
        EventConnection,
        graphql_name="getEventsForIncidents",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventTypes", default=None
                    ),
                ),
                (
                    "incident_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="incidentEndTime", default=None),
                ),
                (
                    "incident_rule_id",
                    sgqlc.types.Arg(UUID, graphql_name="incidentRuleId", default=None),
                ),
                (
                    "incident_full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="incidentFullTableIds",
                        default=None,
                    ),
                ),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Get events by filtering on associated
    incident properties

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `domain_id` (`UUID`): Filter by domain UUID
    * `event_types` (`[String]`): Filter by a list of types
    * `incident_end_time` (`DateTime`): Filter for events belonging to
      incidents older than this time
    * `incident_rule_id` (`UUID`): Filter for events belonging to
      incidents that are associated with this custom rule UUID
    * `incident_full_table_ids` (`[String]`): Filter for events
      belonging to incidents associated with these full table ids
    * `desc_order` (`Boolean`): Returns events in descending order of
      create_time
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_events_for_alerts = sgqlc.types.Field(
        EventConnection,
        graphql_name="getEventsForAlerts",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventTypes", default=None
                    ),
                ),
                (
                    "alert_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="alertEndTime", default=None),
                ),
                ("alert_rule_id", sgqlc.types.Arg(UUID, graphql_name="alertRuleId", default=None)),
                (
                    "alert_full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="alertFullTableIds", default=None
                    ),
                ),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get events by filtering on associated alert
    properties

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `domain_id` (`UUID`): Filter by domain UUID
    * `event_types` (`[String]`): Filter by a list of types
    * `alert_end_time` (`DateTime`): Filter for events belonging to
      alerts older than this time
    * `alert_rule_id` (`UUID`): Filter for events belonging to alerts
      that are associated with this custom rule UUID
    * `alert_full_table_ids` (`[String]`): Filter for events belonging
      to alerts associated with these full table ids
    * `desc_order` (`Boolean`): Returns events in descending order of
      create_time
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_past_comments_for_alert = sgqlc.types.Field(
        EventConnection,
        graphql_name="getPastCommentsForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get past events for a specific alert

    Arguments:

    * `alert_id` (`UUID!`): Filter by alert id
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_comments_for_monitor_incidents = sgqlc.types.Field(
        EventConnection,
        graphql_name="getCommentsForMonitorIncidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="monitorUuids", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get comments associated with incidents that have events created by
    the monitors

    Arguments:

    * `monitor_uuids` (`[UUID]`): Monitor uuids
    * `start_time` (`DateTime`): Filter for comments newer than this
    * `end_time` (`DateTime`): Filter for comments older than this
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_event = sgqlc.types.Field(
        "Event",
        graphql_name="getEvent",
        args=sgqlc.types.ArgDict(
            (("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),)
        ),
    )
    """Arguments:

    * `uuid` (`UUID`)None
    """

    get_event_type_summary = sgqlc.types.Field(
        EventTypeSummary,
        graphql_name="getEventTypeSummary",
        args=sgqlc.types.ArgDict(
            (
                ("resource_id", sgqlc.types.Arg(UUID, graphql_name="resourceId", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
            )
        ),
    )
    """Arguments:

    * `resource_id` (`UUID`)None
    * `start_time` (`DateTime`)None
    * `end_time` (`DateTime`)None
    """

    get_metric_comparison_events = sgqlc.types.Field(
        EventConnection,
        graphql_name="getMetricComparisonEvents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "segmented_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="segmentedValues",
                        default=None,
                    ),
                ),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("source_field", sgqlc.types.Arg(String, graphql_name="sourceField", default=None)),
                ("target_field", sgqlc.types.Arg(String, graphql_name="targetField", default=None)),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=False)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get metric comparison events for the given monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): Monitor for which to retrieve events
    * `start_time` (`DateTime!`): Filter for events created after this
    * `end_time` (`DateTime!`): Filter for events created before this
    * `segmented_values` (`[String!]`): Filter events which for any of
      the given segments.
    * `metric` (`String`): Filter by metric name
    * `source_field` (`String`): Filter by source field name
    * `target_field` (`String`): Filter by target field name
    * `desc_order` (`Boolean`): Returns events in descending order
      (default: `false`)
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_fh_events_by_monitor = sgqlc.types.Field(
        FHEvents,
        graphql_name="getFhEventsByMonitor",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorId", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
                (
                    "where_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="whereConditions",
                        default=None,
                    ),
                ),
                (
                    "segments",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="segments",
                        default=None,
                    ),
                ),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=False)),
            )
        ),
    )
    """(experimental) Get metric monitor events for the given monitor

    Arguments:

    * `monitor_id` (`UUID!`): Monitor for which to retrieve events
    * `start_time` (`DateTime!`): Filter for events created after this
    * `end_time` (`DateTime!`): Filter for events created before this
    * `where_condition` (`String`): Filter by segmented where
      condition
    * `where_conditions` (`[String!]`): Filter events which for any of
      the given where conditions.
    * `segments` (`[String!]`): Filter events which for any of the
      given segments.
    * `metric` (`String`): Filter by metric name
    * `field` (`String`): Filter by field name
    * `first` (`Int`): Number of results to return (default: 1,000)
    * `offset` (`Int`): From which offset to return the next results
    * `desc_order` (`Boolean`): Returns events in descending order
      (default: `false`)
    """

    get_fh_events = sgqlc.types.Field(
        FHEvents,
        graphql_name="getFhEvents",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
                (
                    "where_conditions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="whereConditions",
                        default=None,
                    ),
                ),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "segments",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="segments",
                        default=None,
                    ),
                ),
                (
                    "search_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="searchValues",
                        default=None,
                    ),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=False)),
            )
        ),
    )
    """(experimental) Get metric monitor events for the given incident

    Arguments:

    * `incident_id` (`UUID`): Incident for which to retrieve events.
      Deprecated, use alertId instead
    * `alert_id` (`UUID`): Alert for which to retrieve events
    * `where_condition` (`String`): Filter by segmented where
      condition
    * `where_conditions` (`[String!]`): Filter events which for any of
      the given where conditions.
    * `metric` (`String`): Filter by metric name
    * `field` (`String`): Filter by field name
    * `segments` (`[String!]`): Filter events which for any of the
      given segments.
    * `search_values` (`[String!]`): Filter events which contain any
      of the search values on either their where_condition, metric, or
      field.
    * `first` (`Int`): Number of results to return (default: 1,000)
    * `offset` (`Int`): From which offset to return the next results
    * `desc_order` (`Boolean`): Returns events in descending order
      (default: `false`)
    """

    get_fh_events_where_condition_filter_values = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getFhEventsWhereConditionFilterValues",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
            )
        ),
    )
    """Get possible segmented where conditions for FH events filter

    Arguments:

    * `incident_id` (`UUID`): Incident for which to retrieve filter
      values. Deprecated, use alertId instead
    * `alert_id` (`UUID`): Alert for which to retrieve filter values
    * `metric` (`String`): Filter by metric name
    * `field` (`String`): Filter by field name
    """

    get_fh_events_where_condition_filter_values_paginated = sgqlc.types.Field(
        FHEventsFilterValues,
        graphql_name="getFhEventsWhereConditionFilterValuesPaginated",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                (
                    "search_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="searchValues",
                        default=None,
                    ),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=1000)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=False)),
            )
        ),
    )
    """(experimental) Get possible segmented where conditions for FH
    events filter

    Arguments:

    * `incident_id` (`UUID`): Incident for which to retrieve filter
      values. Deprecated, use alertId instead
    * `alert_id` (`UUID`): Alert for which to retrieve filter values
    * `metric` (`String`): Filter by metric name
    * `field` (`String`): Filter by field name
    * `search_values` (`[String!]`): Filter values which contain any
      of the search values
    * `first` (`Int`): Number of results to return (default: 1,000)
      (default: `1000`)
    * `offset` (`Int`): From which offset to return the next results
      (default: `0`)
    * `desc_order` (`Boolean`): Returns values in descending order
      (default: `false`)
    """

    get_fh_events_metric_filter_values = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getFhEventsMetricFilterValues",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
            )
        ),
    )
    """Get possible metric names for FH events filter

    Arguments:

    * `incident_id` (`UUID`): Incident for which to retrieve filter
      values. Deprecated, use alertId instead
    * `alert_id` (`UUID`): Alert for which to retrieve filter values
    * `where_condition` (`String`): Filter by segmented where
      condition
    * `field` (`String`): Filter by field name
    """

    get_fh_events_field_filter_values = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getFhEventsFieldFilterValues",
        args=sgqlc.types.ArgDict(
            (
                ("incident_id", sgqlc.types.Arg(UUID, graphql_name="incidentId", default=None)),
                ("alert_id", sgqlc.types.Arg(UUID, graphql_name="alertId", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
            )
        ),
    )
    """Get possible field names for FH events filter

    Arguments:

    * `incident_id` (`UUID`): Incident for which to retrieve filter
      values. Deprecated, use alertId instead
    * `alert_id` (`UUID`): Alert for which to retrieve filter values
    * `where_condition` (`String`): Filter by segmented where
      condition
    * `metric` (`String`): Filter by metric name
    """

    get_incidents = sgqlc.types.Field(
        IncidentConnection,
        graphql_name="getIncidents",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "incident_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="incidentTypes", default=None
                    ),
                ),
                (
                    "incident_sub_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentSubType),
                        graphql_name="incidentSubTypes",
                        default=None,
                    ),
                ),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventTypes", default=None
                    ),
                ),
                (
                    "event_states",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventStates", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "incident_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="incidentIds", default=None
                    ),
                ),
                (
                    "owners",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="owners", default=None
                    ),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "projects",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="projects", default=None
                    ),
                ),
                (
                    "datasets",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="datasets", default=None
                    ),
                ),
                (
                    "tables",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tables", default=None
                    ),
                ),
                (
                    "full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fullTableIds", default=None
                    ),
                ),
                (
                    "include_timeline_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeTimelineEvents", default=None),
                ),
                (
                    "include_anomaly_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeAnomalyEvents", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "monitor_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="monitorIds", default=None
                    ),
                ),
                ("rule_id", sgqlc.types.Arg(UUID, graphql_name="ruleId", default=None)),
                (
                    "tag_key_value_pairs",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput),
                        graphql_name="tagKeyValuePairs",
                        default=None,
                    ),
                ),
                (
                    "tag_key_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagPair), graphql_name="tagKeyValues", default=None
                    ),
                ),
                (
                    "tag_keys",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tagKeys", default=None
                    ),
                ),
                (
                    "min_event_count",
                    sgqlc.types.Arg(Int, graphql_name="minEventCount", default=None),
                ),
                (
                    "max_event_count",
                    sgqlc.types.Arg(Int, graphql_name="maxEventCount", default=None),
                ),
                (
                    "contains_key_asset",
                    sgqlc.types.Arg(Boolean, graphql_name="containsKeyAsset", default=None),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "has_jira_tickets",
                    sgqlc.types.Arg(Boolean, graphql_name="hasJiraTickets", default=None),
                ),
                (
                    "has_servicenow_incidents",
                    sgqlc.types.Arg(Boolean, graphql_name="hasServicenowIncidents", default=None),
                ),
                (
                    "has_opsgenie_incidents",
                    sgqlc.types.Arg(Boolean, graphql_name="hasOpsgenieIncidents", default=None),
                ),
                (
                    "job_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobMcons", default=None
                    ),
                ),
                (
                    "audience_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="audienceUuids", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Get incidents (i.e. a collection of
    related events) in my account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `incident_types` (`[String]`): Filter by type of incident (e.g.
      anomalies)
    * `incident_sub_types` (`[IncidentSubType]`): Filter by incident
      sub type (e.g. freshness_anomaly)
    * `event_types` (`[String]`): Filter by type of event as an
      incident can have multiple event types
    * `event_states` (`[String]`): Filter by the state individual
      events are in
    * `start_time` (`DateTime`): Filter for incidents newer than this
    * `end_time` (`DateTime`): Filter for incidents older than this
    * `incident_ids` (`[UUID]`): Filter for specific incidents
    * `owners` (`[String]`): Filter for specific owners
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `include_feedback` (`[String]`): Filter by user feedback
    * `exclude_feedback` (`[String]`): Exclude by user feedback
    * `projects` (`[String]`): Filter by projects
    * `datasets` (`[String]`): Filter by datasets
    * `tables` (`[String]`): Filter by tables
    * `full_table_ids` (`[String]`): Filter by full table ids
    * `include_timeline_events` (`Boolean`): Flag decides whether to
      include timeline events or not. By default it's false. If
      event_types field set, this will be ignored too.
    * `include_anomaly_events` (`Boolean`): Flag decides whether to
      include anomaly events or not. By default it's false. If
      event_types field set, this will be ignored too.
    * `domain_id` (`UUID`): Filter by domain UUID
    * `monitor_ids` (`[UUID]`): Filter for specific monitors
    * `rule_id` (`UUID`): Filter by custom rule UUID
    * `tag_key_value_pairs` (`[TagKeyValuePairInput]`): Filter by tag
      key values
    * `tag_key_values` (`[TagPair]`): (Deprecated, use
      `tag_key_value_pairs` instead) Filter by tag key values
    * `tag_keys` (`[String]`): (Deprecated, use `tag_key_value_pairs`
      instead) Filter by tag keys
    * `min_event_count` (`Int`): Filter to incidents with at least
      this many events
    * `max_event_count` (`Int`): Filter to incidents with at most this
      many events
    * `contains_key_asset` (`Boolean`): If true, filter to incidents
      containing a key asset
    * `include_normalized` (`Boolean`): If false, filter out
      normalized events.
    * `has_jira_tickets` (`Boolean`): If false, include incidents
      without jira tickets. If true, include incidents with jira
      tickets. If null, return all incidents.
    * `has_servicenow_incidents` (`Boolean`): If false, include
      incidents without ServiceNow incidents. If true, include
      incidents with ServiceNow incidents. If null, return all
      incidents.
    * `has_opsgenie_incidents` (`Boolean`): If false, include
      incidents without Opsgenie incidents. If true, include incidents
      with Opsgenie incidents. If null, return all incidents.
    * `job_mcons` (`[String]`): If provided, filter incidents by job
      mcons
    * `audience_uuids` (`[UUID]`): Filter for specific audience uuids
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `order_by` (`String`): Ordering
    """

    get_incidents_count_by_date = sgqlc.types.Field(
        IncidentsCountByDateConnection,
        graphql_name="getIncidentsCountByDate",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "incident_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="incidentTypes", default=None
                    ),
                ),
                (
                    "incident_sub_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentSubType),
                        graphql_name="incidentSubTypes",
                        default=None,
                    ),
                ),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventTypes", default=None
                    ),
                ),
                (
                    "event_states",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="eventStates", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "incident_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="incidentIds", default=None
                    ),
                ),
                (
                    "owners",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="owners", default=None
                    ),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "projects",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="projects", default=None
                    ),
                ),
                (
                    "datasets",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="datasets", default=None
                    ),
                ),
                (
                    "tables",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tables", default=None
                    ),
                ),
                (
                    "full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fullTableIds", default=None
                    ),
                ),
                (
                    "include_timeline_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeTimelineEvents", default=None),
                ),
                (
                    "include_anomaly_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeAnomalyEvents", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "monitor_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="monitorIds", default=None
                    ),
                ),
                ("rule_id", sgqlc.types.Arg(UUID, graphql_name="ruleId", default=None)),
                (
                    "tag_key_value_pairs",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput),
                        graphql_name="tagKeyValuePairs",
                        default=None,
                    ),
                ),
                (
                    "tag_key_values",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagPair), graphql_name="tagKeyValues", default=None
                    ),
                ),
                (
                    "tag_keys",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tagKeys", default=None
                    ),
                ),
                (
                    "min_event_count",
                    sgqlc.types.Arg(Int, graphql_name="minEventCount", default=None),
                ),
                (
                    "max_event_count",
                    sgqlc.types.Arg(Int, graphql_name="maxEventCount", default=None),
                ),
                (
                    "contains_key_asset",
                    sgqlc.types.Arg(Boolean, graphql_name="containsKeyAsset", default=None),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "has_jira_tickets",
                    sgqlc.types.Arg(Boolean, graphql_name="hasJiraTickets", default=None),
                ),
                (
                    "has_servicenow_incidents",
                    sgqlc.types.Arg(Boolean, graphql_name="hasServicenowIncidents", default=None),
                ),
                (
                    "has_opsgenie_incidents",
                    sgqlc.types.Arg(Boolean, graphql_name="hasOpsgenieIncidents", default=None),
                ),
                (
                    "job_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobMcons", default=None
                    ),
                ),
                (
                    "audience_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="audienceUuids", default=None
                    ),
                ),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Get incidents (i.e. a collection of
    related events) in my account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `incident_types` (`[String]`): Filter by type of incident (e.g.
      anomalies)
    * `incident_sub_types` (`[IncidentSubType]`): Filter by incident
      sub type (e.g. freshness_anomaly)
    * `event_types` (`[String]`): Filter by type of event as an
      incident can have multiple event types
    * `event_states` (`[String]`): Filter by the state individual
      events are in
    * `start_time` (`DateTime`): Filter for incidents newer than this
    * `end_time` (`DateTime`): Filter for incidents older than this
    * `incident_ids` (`[UUID]`): Filter for specific incidents
    * `owners` (`[String]`): Filter for specific owners
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `include_feedback` (`[String]`): Filter by user feedback
    * `exclude_feedback` (`[String]`): Exclude by user feedback
    * `projects` (`[String]`): Filter by projects
    * `datasets` (`[String]`): Filter by datasets
    * `tables` (`[String]`): Filter by tables
    * `full_table_ids` (`[String]`): Filter by full table ids
    * `include_timeline_events` (`Boolean`): Flag decides whether to
      include timeline events or not. By default it's false. If
      event_types field set, this will be ignored too.
    * `include_anomaly_events` (`Boolean`): Flag decides whether to
      include anomaly events or not. By default it's false. If
      event_types field set, this will be ignored too.
    * `domain_id` (`UUID`): Filter by domain UUID
    * `monitor_ids` (`[UUID]`): Filter for specific monitors
    * `rule_id` (`UUID`): Filter by custom rule UUID
    * `tag_key_value_pairs` (`[TagKeyValuePairInput]`): Filter by tag
      key values
    * `tag_key_values` (`[TagPair]`): (Deprecated, use
      `tag_key_value_pairs` instead) Filter by tag key values
    * `tag_keys` (`[String]`): (Deprecated, use `tag_key_value_pairs`
      instead) Filter by tag keys
    * `min_event_count` (`Int`): Filter to incidents with at least
      this many events
    * `max_event_count` (`Int`): Filter to incidents with at most this
      many events
    * `contains_key_asset` (`Boolean`): If true, filter to incidents
      containing a key asset
    * `include_normalized` (`Boolean`): If false, filter out
      normalized events.
    * `has_jira_tickets` (`Boolean`): If false, include incidents
      without jira tickets. If true, include incidents with jira
      tickets. If null, return all incidents.
    * `has_servicenow_incidents` (`Boolean`): If false, include
      incidents without ServiceNow incidents. If true, include
      incidents with ServiceNow incidents. If null, return all
      incidents.
    * `has_opsgenie_incidents` (`Boolean`): If false, include
      incidents without Opsgenie incidents. If true, include incidents
      with Opsgenie incidents. If null, return all incidents.
    * `job_mcons` (`[String]`): If provided, filter incidents by job
      mcons
    * `audience_uuids` (`[UUID]`): Filter for specific audience uuids
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_incidents_filters = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentsFilter), graphql_name="getIncidentsFilters"
    )
    """(experimental) DEPRECATED. Filters that can be applied when
    requesting for a list of incidents
    """

    get_incidents_filters_data = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentsFilterData),
        graphql_name="getIncidentsFiltersData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(IncidentsFilterDataRequestType)),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Get possible values for incident
    filters

    Arguments:

    * `request` (`[IncidentsFilterDataRequestType]!`)None
    """

    get_incident_type_summary = sgqlc.types.Field(
        IncidentTypeSummary,
        graphql_name="getIncidentTypeSummary",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Get a summary of counts by type for
    incidents in the account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `start_time` (`DateTime`): Filter for incidents newer than this
    * `end_time` (`DateTime`): Filter for incidents older than this
    * `domain_id` (`UUID`): Filter by domain UUID
    """

    get_alert_type_summary = sgqlc.types.Field(
        AlertTypeSummary,
        graphql_name="getAlertTypeSummary",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Get a summary of counts by type for alerts in the account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `start_time` (`DateTime`): Filter for alerts newer than this
    * `end_time` (`DateTime`): Filter for alerts older than this
    * `domain_id` (`UUID`): Filter by domain UUID
    """

    get_incident_notification_settings_used = sgqlc.types.Field(
        sgqlc.types.list_of(AccountNotificationSetting),
        graphql_name="getIncidentNotificationSettingsUsed",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. The notification settings that were
    used to send notifications for the incident

    Arguments:

    * `incident_id` (`UUID!`): The incident UUID
    """

    get_alert_notification_settings_used = sgqlc.types.Field(
        sgqlc.types.list_of(AccountNotificationSetting),
        graphql_name="getAlertNotificationSettingsUsed",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) The notification settings that were used to send
    notifications for the alert

    Arguments:

    * `alert_id` (`UUID!`): The alert UUID
    """

    get_slack_messages_for_incident = sgqlc.types.Field(
        sgqlc.types.list_of("SlackMessageDetails"),
        graphql_name="getSlackMessagesForIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Get slack messages for incident

    Arguments:

    * `incident_id` (`UUID!`): Filter by incident id
    """

    get_slack_messages_for_alert = sgqlc.types.Field(
        sgqlc.types.list_of("SlackMessageDetails"),
        graphql_name="getSlackMessagesForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get slack messages for alert

    Arguments:

    * `alert_id` (`UUID!`): Filter by alert id
    """

    get_slack_engagements_for_incident = sgqlc.types.Field(
        sgqlc.types.list_of("SlackEngagement"),
        graphql_name="getSlackEngagementsForIncident",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentId", default=None
                    ),
                ),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(SlackEngagementEventType),
                        graphql_name="eventTypes",
                        default=None,
                    ),
                ),
                (
                    "exclude_bot_engagements",
                    sgqlc.types.Arg(Boolean, graphql_name="excludeBotEngagements", default=None),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Get slack engagements for incident

    Arguments:

    * `incident_id` (`UUID!`): Filter by incident id
    * `event_types` (`[SlackEngagementEventType]`): Filter by
      event_type (e.g. thread_reply, reaction_added)
    * `exclude_bot_engagements` (`Boolean`): Exclude bot engagements
    """

    get_slack_engagements_for_alert = sgqlc.types.Field(
        sgqlc.types.list_of("SlackEngagement"),
        graphql_name="getSlackEngagementsForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(SlackEngagementEventType),
                        graphql_name="eventTypes",
                        default=None,
                    ),
                ),
                (
                    "exclude_bot_engagements",
                    sgqlc.types.Arg(Boolean, graphql_name="excludeBotEngagements", default=None),
                ),
            )
        ),
    )
    """(experimental) Get slack engagements for alert

    Arguments:

    * `alert_id` (`UUID!`): Filter by alert id
    * `event_types` (`[SlackEngagementEventType]`): Filter by
      event_type (e.g. thread_reply, reaction_added)
    * `exclude_bot_engagements` (`Boolean`): Exclude bot engagements
    """

    get_past_slack_engagements_for_alert = sgqlc.types.Field(
        "SlackEngagementConnection",
        graphql_name="getPastSlackEngagementsForAlert",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get past slack engagements for a specific alert

    Arguments:

    * `alert_id` (`UUID!`): Filter by alert id
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_slack_engagements_for_incidents = sgqlc.types.Field(
        "SlackEngagementConnection",
        graphql_name="getSlackEngagementsForIncidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(SlackEngagementEventType),
                        graphql_name="eventTypes",
                        default=None,
                    ),
                ),
                (
                    "exclude_bot_engagements",
                    sgqlc.types.Arg(Boolean, graphql_name="excludeBotEngagements", default=None),
                ),
                (
                    "incident_domain_id",
                    sgqlc.types.Arg(UUID, graphql_name="incidentDomainId", default=None),
                ),
                (
                    "incident_dw_id",
                    sgqlc.types.Arg(UUID, graphql_name="incidentDwId", default=None),
                ),
                (
                    "incident_full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="incidentFullTableIds",
                        default=None,
                    ),
                ),
                (
                    "incident_rule_id",
                    sgqlc.types.Arg(UUID, graphql_name="incidentRuleId", default=None),
                ),
                (
                    "incident_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="incidentEndTime", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) DEPRECATED. Get slack engagements by filtering on
    the associated incident's properties

    Arguments:

    * `event_types` (`[SlackEngagementEventType]`): Filter by
      event_type (e.g. thread_reply, reaction_added)
    * `exclude_bot_engagements` (`Boolean`): Exclude bot engagements
    * `incident_domain_id` (`UUID`): Filter by domain UUID
    * `incident_dw_id` (`UUID`): Filter by incidents from a specific
      warehouse
    * `incident_full_table_ids` (`[String]`): Filter by incidents
      associated with list of full table ids (e.g.
      project:dataset.table)
    * `incident_rule_id` (`UUID`): Filter by incidents associated with
      a custom rule UUID
    * `incident_end_time` (`DateTime`): Filter by incidents older than
      this time
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_slack_engagements_for_alerts = sgqlc.types.Field(
        "SlackEngagementConnection",
        graphql_name="getSlackEngagementsForAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "event_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(SlackEngagementEventType),
                        graphql_name="eventTypes",
                        default=None,
                    ),
                ),
                (
                    "exclude_bot_engagements",
                    sgqlc.types.Arg(Boolean, graphql_name="excludeBotEngagements", default=None),
                ),
                (
                    "alert_domain_id",
                    sgqlc.types.Arg(UUID, graphql_name="alertDomainId", default=None),
                ),
                ("alert_dw_id", sgqlc.types.Arg(UUID, graphql_name="alertDwId", default=None)),
                (
                    "alert_full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="alertFullTableIds", default=None
                    ),
                ),
                ("alert_rule_id", sgqlc.types.Arg(UUID, graphql_name="alertRuleId", default=None)),
                (
                    "alert_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="alertEndTime", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get slack engagements by filtering on the
    associated alert's properties

    Arguments:

    * `event_types` (`[SlackEngagementEventType]`): Filter by
      event_type (e.g. thread_reply, reaction_added)
    * `exclude_bot_engagements` (`Boolean`): Exclude bot engagements
    * `alert_domain_id` (`UUID`): Filter by domain UUID
    * `alert_dw_id` (`UUID`): Filter by alerts from a specific
      warehouse
    * `alert_full_table_ids` (`[String]`): Filter by alerts associated
      with list of full table ids (e.g. project:dataset.table)
    * `alert_rule_id` (`UUID`): Filter by alerts associated with a
      custom rule UUID
    * `alert_end_time` (`DateTime`): Filter by alerts older than this
      time
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_incident_timeline_events = sgqlc.types.Field(
        "TimelineEventData",
        graphql_name="getIncidentTimelineEvents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "incident_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="incidentUuid", default=None
                    ),
                ),
            )
        ),
    )
    """DEPRECATED. Fetches timeline events for an incident

    Arguments:

    * `incident_uuid` (`UUID!`): Incident identifier
    """

    get_all_domains = sgqlc.types.Field(
        sgqlc.types.list_of(DomainOutput), graphql_name="getAllDomains"
    )
    """Get all available domains"""

    get_domain = sgqlc.types.Field(
        DomainOutput,
        graphql_name="getDomain",
        args=sgqlc.types.ArgDict(
            (
                (
                    "uuid",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="uuid", default=None),
                ),
            )
        ),
    )
    """Get domain by id

    Arguments:

    * `uuid` (`UUID!`): Domain UUID
    """

    get_account_roles = sgqlc.types.Field(
        sgqlc.types.list_of("RoleOutput"), graphql_name="getAccountRoles"
    )
    """Get roles available for current user's account."""

    get_authorization_groups = sgqlc.types.Field(
        sgqlc.types.list_of(AuthorizationGroupOutput), graphql_name="getAuthorizationGroups"
    )
    """Get authorization group list for the user's account."""

    get_user_authorization = sgqlc.types.Field(
        "UserAuthorizationOutput", graphql_name="getUserAuthorization"
    )
    """Get resolved authorization info for the user."""

    get_authorization_provisioning = sgqlc.types.Field(
        AuthorizationProvisioningOutput, graphql_name="getAuthorizationProvisioning"
    )
    """(experimental) Get the authorization provisioning config for this
    account.
    """

    get_access_request = sgqlc.types.Field(
        AccessRequest,
        graphql_name="getAccessRequest",
        args=sgqlc.types.ArgDict(
            (
                (
                    "target_permission",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Permission),
                        graphql_name="targetPermission",
                        default=None,
                    ),
                ),
                ("target_id", sgqlc.types.Arg(String, graphql_name="targetId", default=None)),
                ("reason", sgqlc.types.Arg(String, graphql_name="reason", default=None)),
            )
        ),
    )
    """(experimental) Get the status of an alert access request for the
    current user

    Arguments:

    * `target_permission` (`Permission!`): Permission requested
    * `target_id` (`String`): Object ID access was requested for
    * `reason` (`String`): Reason for requesting access
    """

    search = sgqlc.types.Field(
        "SearchResponse",
        graphql_name="search",
        args=sgqlc.types.ArgDict(
            (
                (
                    "object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="objectTypes", default=None
                    ),
                ),
                (
                    "ignore_object_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="ignoreObjectTypes", default=None
                    ),
                ),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=50)),
                (
                    "full_results",
                    sgqlc.types.Arg(Boolean, graphql_name="fullResults", default=True),
                ),
                ("operator", sgqlc.types.Arg(String, graphql_name="operator", default="OR")),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("parent_mcon", sgqlc.types.Arg(String, graphql_name="parentMcon", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                ("tags_only", sgqlc.types.Arg(Boolean, graphql_name="tagsOnly", default=False)),
                (
                    "include_facet_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(FacetType),
                        graphql_name="includeFacetTypes",
                        default=None,
                    ),
                ),
                (
                    "facet_results_limit",
                    sgqlc.types.Arg(Int, graphql_name="facetResultsLimit", default=10),
                ),
                (
                    "tags",
                    sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="tags", default=None),
                ),
                (
                    "tag_name_query",
                    sgqlc.types.Arg(String, graphql_name="tagNameQuery", default=None),
                ),
                (
                    "tag_value_query",
                    sgqlc.types.Arg(String, graphql_name="tagValueQuery", default=None),
                ),
                (
                    "resource_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="resourceIds", default=None
                    ),
                ),
                (
                    "tag_filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagFilterInput), graphql_name="tagFilters", default=None
                    ),
                ),
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
                (
                    "is_monitored",
                    sgqlc.types.Arg(Boolean, graphql_name="isMonitored", default=None),
                ),
                (
                    "project_filter",
                    sgqlc.types.Arg(ProjectFilterInput, graphql_name="projectFilter", default=None),
                ),
                (
                    "dataset_filter",
                    sgqlc.types.Arg(DatasetFilterInput, graphql_name="datasetFilter", default=None),
                ),
                (
                    "data_product_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="dataProductIds",
                        default=None,
                    ),
                ),
                (
                    "warehouse_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="warehouseTypes", default=None
                    ),
                ),
                (
                    "etl_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="etlTypes", default=None
                    ),
                ),
                (
                    "bi_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="biTypes", default=None
                    ),
                ),
                (
                    "order_by_table_component",
                    sgqlc.types.Arg(Boolean, graphql_name="orderByTableComponent", default=None),
                ),
            )
        ),
    )
    """Search catalog for an entity

    Arguments:

    * `object_types` (`[String]`): Filter by object type (e.g. table,
      view, etc.)
    * `ignore_object_types` (`[String]`): Filter out by object type
    * `query` (`String`): Entity to search for
    * `offset` (`Int`): Offset when paging (default: `0`)
    * `limit` (`Int`): Max results (default: `50`)
    * `full_results` (`Boolean`): Full search mode, used to search all
      available fields, not just display_name (default: `true`)
    * `operator` (`String`): Search operator to use, either OR or AND
      (DEPRECATED) (default: `"OR"`)
    * `mcon` (`String`): Filter on mcon
    * `mcons` (`[String]`): Filter on multiple mcons
    * `parent_mcon` (`String`): Filter on parent_mcon
    * `domain_id` (`UUID`): Filter by domain UUID
    * `tags_only` (`Boolean`): Search only tags and descriptions (no
      display_name) (default: `false`)
    * `include_facet_types` (`[FacetType]`): Facet types to include
      (tags, tag_names, tag_values)
    * `facet_results_limit` (`Int`): Facet results limit (default:
      `10`)
    * `tags` (`[String]`): Filter by tags (DEPRECATED, use tagFilters)
    * `tag_name_query` (`String`): Query tag names (DEPRECATED)
    * `tag_value_query` (`String`): Query tag values (DEPRECATED)
    * `resource_ids` (`[String]`): Filter by resource ID
    * `tag_filters` (`[TagFilterInput]`): List of tag filters
    * `monitor_type` (`String`): Exclude from results objects that do
      not support this monitor type
    * `is_monitored` (`Boolean`): Filter by is_monitored status. Only
      applicable to tables
    * `project_filter` (`ProjectFilterInput`): Project filter
    * `dataset_filter` (`DatasetFilterInput`): Dataset filter
    * `data_product_ids` (`[UUID!]`): Filter by data product IDs
    * `warehouse_types` (`[String]`): Filter by warehouse types
    * `etl_types` (`[String]`): Filter by ETL types
    * `bi_types` (`[String]`): Filter by BI types
    * `order_by_table_component` (`Boolean`): Order results by
      project, dataset, everything else.
    """

    search_tables_for_dynamic_schedule = sgqlc.types.Field(
        CategorizedSearchResponse,
        graphql_name="searchTablesForDynamicSchedule",
        args=sgqlc.types.ArgDict(
            (
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=50)),
                (
                    "data_source",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataSourceUnionInput),
                        graphql_name="dataSource",
                        default=None,
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "resource_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="resourceId", default=None
                    ),
                ),
                (
                    "connection_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="connectionUuid", default=None),
                ),
            )
        ),
    )
    """(experimental) This is to fetch tables for dynamic schedule

    Arguments:

    * `query` (`String`): Entity to search for
    * `limit` (`Int`): Max results (default: `50`)
    * `data_source` (`DataSourceUnionInput!`)None
    * `domain_id` (`UUID`): Filter by domain UUID
    * `resource_id` (`UUID!`): warehouse UUID
    * `connection_uuid` (`UUID`): Connection UUID
    """

    get_object = sgqlc.types.Field(
        ObjectDocument,
        graphql_name="getObject",
        args=sgqlc.types.ArgDict(
            (("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),)
        ),
    )
    """Arguments:

    * `mcon` (`String`)None
    """

    get_metadata = sgqlc.types.Field(
        sgqlc.types.list_of(ObjectDocument),
        graphql_name="getMetadata",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `mcons` (`[String]`)None
    """

    get_metrics_v4 = sgqlc.types.Field(
        Metrics,
        graphql_name="getMetricsV4",
        args=sgqlc.types.ArgDict(
            (
                (
                    "metric_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metricName", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "metrics_filter",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(MetricsFilter),
                        graphql_name="metricsFilter",
                        default=None,
                    ),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                (
                    "deduplicate_values",
                    sgqlc.types.Arg(Boolean, graphql_name="deduplicateValues", default=None),
                ),
            )
        ),
    )
    """Retrieves metric data points by time range and filters

    Arguments:

    * `metric_name` (`String!`): Name of the metric
    * `start_time` (`DateTime!`): Filter for data newer than this
    * `end_time` (`DateTime`): Filter for data older than this.
      Defaults to current time.
    * `metrics_filter` (`MetricsFilter!`): Filters for the metrics to
      be fetched
    * `first` (`Int`): Number of data points to retrieve. Defaults to
      5000.
    * `deduplicate_values` (`Boolean`): Deduplicate the data points by
      `value`. Defaults to false.
    """

    get_field_metric_definitions = sgqlc.types.Field(
        sgqlc.types.list_of(FieldMetricDefinition),
        graphql_name="getFieldMetricDefinitions",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                (
                    "metric_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="metricNames", default=None
                    ),
                ),
                ("field_type", sgqlc.types.Arg(FieldType, graphql_name="fieldType", default=None)),
                ("version", sgqlc.types.Arg(Int, graphql_name="version", default=None)),
                ("monitor_type", sgqlc.types.Arg(String, graphql_name="monitorType", default=None)),
            )
        ),
    )
    """Retrieves definitions of the list of available field metrics,
    optionally filtering them by name.

    Arguments:

    * `warehouse_uuid` (`UUID!`): Warehouse UUID
    * `metric_names` (`[String]`): Names of field metrics to return in
      the response
    * `field_type` (`FieldType`): Field type for which to return field
      metrics
    * `version` (`Int`): Version of the monitor
    * `monitor_type` (`String`): Filter by monitor type
    """

    get_comparison_monitor_field_metric_definitions = sgqlc.types.Field(
        sgqlc.types.list_of(FieldMetricDefinition),
        graphql_name="getComparisonMonitorFieldMetricDefinitions",
        args=sgqlc.types.ArgDict(
            (
                (
                    "source_warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="sourceWarehouseUuid", default=None
                    ),
                ),
                (
                    "target_warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="targetWarehouseUuid", default=None
                    ),
                ),
                (
                    "metric_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="metricNames", default=None
                    ),
                ),
                ("field_type", sgqlc.types.Arg(FieldType, graphql_name="fieldType", default=None)),
            )
        ),
    )
    """(experimental) Retrieves definitions of the list of available
    field metrics common to both source and target warehouses
    optionally filtering them by name.

    Arguments:

    * `source_warehouse_uuid` (`UUID!`): Source warehouse UUID
    * `target_warehouse_uuid` (`UUID!`): Target warehouse UUID
    * `metric_names` (`[String]`): Names of field metrics to return in
      the response
    * `field_type` (`FieldType`): Field type for which to return field
      metrics
    """

    get_top_segmented_where_condition_labels = sgqlc.types.Field(
        sgqlc.types.list_of(CategoryLabelRank),
        graphql_name="getTopSegmentedWhereConditionLabels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """(experimental) Get the top segmented where_conditions for a metric
    monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): The monitor for which to fetch the
      labels
    * `start_time` (`DateTime`): Filter for data newer than this
    * `limit` (`Int`): Limit results retrieved
    """

    get_segmented_where_condition_labels = sgqlc.types.Field(
        sgqlc.types.list_of("WhereConditionSegments"),
        graphql_name="getSegmentedWhereConditionLabels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                (
                    "include_terms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="includeTerms",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get segmented where_conditions for a metric monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): The monitor for which to locate labels
    * `warehouse_uuid` (`UUID`): DEPRECATED
    * `first` (`Int`): Number of results to return (default/max:
      10,000)
    * `after` (`String`): Fetch batch of 'first' results after this
      value
    * `include_terms` (`[String!]`): Filter to segments where all
      terms are present in segment fields
    """

    get_segmented_where_condition_label_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int),
        graphql_name="getSegmentedWhereConditionLabelCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
                (
                    "include_terms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="includeTerms",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get approximate segmented where_condition count for
    a metric monitor. Higher counts may not be exact for performance
    reasons.

    Arguments:

    * `monitor_uuid` (`UUID!`): The monitor for which to locate labels
    * `warehouse_uuid` (`UUID`): DEPRECATED
    * `include_terms` (`[String!]`): Filter to segments where all
      terms are present in segment fields
    """

    get_comparison_monitor_segment_labels = sgqlc.types.Field(
        "SegmentLabels",
        graphql_name="getComparisonMonitorSegmentLabels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                (
                    "include_terms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="includeTerms",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get segment labels for a comparison monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): Filter to this monitor.
    * `first` (`Int`): Number of results to return. Default: 1,000.
      Max: 10,000.
    * `after` (`String`): Fetch batch of 'first' results after this
      value.
    * `include_terms` (`[String!]`): Filter to segments where all
      terms are present in segment label
    """

    get_comparison_monitor_segment_label_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int),
        graphql_name="getComparisonMonitorSegmentLabelCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "include_terms",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(String)),
                        graphql_name="includeTerms",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get segment label count for a comparison monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): Filter to this monitor.
    * `include_terms` (`[String!]`): Filter to segments where all
      terms are present in segment label
    """

    get_downstream_bi = sgqlc.types.Field(
        sgqlc.types.list_of(DownstreamBI),
        graphql_name="getDownstreamBi",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "node_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="nodeIds", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
            )
        ),
    )
    """Arguments:

    * `dw_id` (`UUID`)None
    * `node_ids` (`[String]`)None
    * `start_time` (`DateTime`)None
    * `end_time` (`DateTime`)None
    """

    get_downstream_impact_radius_summary = sgqlc.types.Field(
        DownstreamImpactRadiusSummary,
        graphql_name="getDownstreamImpactRadiusSummary",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `mcons` (`[String]!`): List of MCONs where each MCON identifies
      a table whose downstream reports are being queried.
    """

    get_downstream_reports = sgqlc.types.Field(
        DownstreamReports,
        graphql_name="getDownstreamReports",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                ("name_matcher", sgqlc.types.Arg(String, graphql_name="nameMatcher", default=None)),
                (
                    "report_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="reportTypes", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("sort_by", sgqlc.types.Arg(String, graphql_name="sortBy", default=None)),
                ("sort_desc", sgqlc.types.Arg(Boolean, graphql_name="sortDesc", default=None)),
            )
        ),
    )
    """Gets downstream reports for a list of tables.

    Arguments:

    * `mcons` (`[String]!`): List of MCONs where each MCON identifies
      a table whose downstream reports are being queried.
    * `name_matcher` (`String`): A string to filter names by
      performing substring match.
    * `report_types` (`[String]`): Report types to query.
    * `limit` (`Int`): Limit results returned
    * `offset` (`Int`): Offset when paging
    * `sort_by` (`String`): Sort by property: [last_updated, owner_id,
      display_name, type, importance_score]
    * `sort_desc` (`Boolean`): Sort in descending order
    """

    get_downstream_report_owners = sgqlc.types.Field(
        DownstreamReportOwners,
        graphql_name="getDownstreamReportOwners",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """Gets owners of downstream reports for a list of tables.

    Arguments:

    * `mcons` (`[String]!`): List of MCONs where each MCON identifies
      a table whose downstream report owners are being queried.
    * `limit` (`Int`): Limit results returned
    * `offset` (`Int`): Offset when paging
    """

    get_downstream_report_types = sgqlc.types.Field(
        DownstreamReportTypes,
        graphql_name="getDownstreamReportTypes",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
            )
        ),
    )
    """Gets all report types of downstream reports for a table.

    Arguments:

    * `mcon` (`String`): MCON of the table whose downstream reports
      are being queried.
    * `mcons` (`[String]`): List of MCONs of the tables whose
      downstream reports are being queried.
    """

    get_table_lineage = sgqlc.types.Field(
        LineageGraph,
        graphql_name="getTableLineage",
        args=sgqlc.types.ArgDict(
            (
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                (
                    "direction",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="direction", default=None
                    ),
                ),
                ("hops", sgqlc.types.Arg(Int, graphql_name="hops", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=500)),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(LineageFilter), graphql_name="filters", default=()
                    ),
                ),
            )
        ),
    )
    """Gets the lineage for an asset up to specified number of hops in
    the lineage graph.

    Arguments:

    * `mcon` (`String`): MCON of the asset whose lineage is being
      queried. Must provide either mcon or mcons.
    * `mcons` (`[String]`): MCONs of the assets whose lineage is being
      queried to a maximum of 12. Must provide either mcons or mcon.
    * `direction` (`String!`): This can be either 'upstream' or
      'downstream' based on the direction in which to traverse the
      lineage graph
    * `hops` (`Int`): The number of hops to query in the lineage
      graph. Defaults to 1.
    * `start_time` (`DateTime`): Filter for lineage data newer than
      this. Defaults to no date filtering.
    * `end_time` (`DateTime`): Filter for lineage data older than
      this. Defaults to no date filtering.
    * `limit` (`Int`): Maximum number of connected nodes to return.
      Defaults to 500 (default: `500`)
    * `filters` (`[LineageFilter]`): List of lineage filters (default:
      `[]`)
    """

    get_table_lineage_v2 = sgqlc.types.Field(
        NodeEdgeGraph,
        graphql_name="getTableLineageV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                (
                    "direction",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LineageGraphTraversalDirection),
                        graphql_name="direction",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(LineageFilter), graphql_name="filters", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Load the whole lineage in one go, upstream.

    Arguments:

    * `mcons` (`[String]!`): MCONs of the tables whose lineage is
      being queried to a maximum of 12. Must provide either mcons or
      mcon.
    * `direction` (`LineageGraphTraversalDirection!`): This can be
      either 'upstream', 'downstream' based on the direction in which
      to traverse the lineage graph
    * `filters` (`[LineageFilter]`): List of lineage filters
    """

    get_table_lineage_v3 = sgqlc.types.Field(
        NodeEdgeStrings,
        graphql_name="getTableLineageV3",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                (
                    "direction",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LineageGraphTraversalDirection),
                        graphql_name="direction",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(LineageFilter), graphql_name="filters", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Load the whole lineage in one go, upstream.

    Arguments:

    * `mcons` (`[String]!`): MCONs of the tables whose lineage is
      being queried to a maximum of 12. Must provide either mcons or
      mcon.
    * `direction` (`LineageGraphTraversalDirection!`): This can be
      either 'upstream', 'downstream' based on the direction in which
      to traverse the lineage graph
    * `filters` (`[LineageFilter]`): List of lineage filters
    """

    get_table_lineage_v4 = sgqlc.types.Field(
        NodeEdgeCSVStrings,
        graphql_name="getTableLineageV4",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                (
                    "direction",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(LineageGraphTraversalDirection),
                        graphql_name="direction",
                        default=None,
                    ),
                ),
                (
                    "filters",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(LineageFilter), graphql_name="filters", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Load the whole lineage in one go and return
    it as CSV data.

    Arguments:

    * `mcons` (`[String]!`): MCONs of the tables whose lineage is
      being queried to a maximum of 12.
    * `direction` (`LineageGraphTraversalDirection!`): This can be
      either 'upstream', 'downstream' based on the direction in which
      to traverse the lineage graph
    * `filters` (`[LineageFilter]`): List of lineage filters
    """

    get_table_lineage_jobs = sgqlc.types.Field(
        LineageGraphNodesEdgesJobs,
        graphql_name="getTableLineageJobs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "node_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="nodeMcons", default=None
                    ),
                ),
                (
                    "edges",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(LineageEdgeInput), graphql_name="edges", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get jobs attached to lineage nodes or edges

    Arguments:

    * `node_mcons` (`[String]`): Table MCONs to query job information
      for. Supply this OR `edges`.
    * `edges` (`[LineageEdgeInput]`): Edges to query job information
      for. Supply this OR `node_mcons`.
    """

    get_connected_mcon_lineage = sgqlc.types.Field(
        ConnectedMcons,
        graphql_name="getConnectedMconLineage",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                (
                    "direction",
                    sgqlc.types.Arg(
                        LineageGraphTraversalDirection, graphql_name="direction", default=None
                    ),
                ),
                ("levels", sgqlc.types.Arg(Int, graphql_name="levels", default=1)),
            )
        ),
    )
    """Get mcon and and directly connected mcons

    Arguments:

    * `mcons` (`[String]!`)None
    * `direction` (`LineageGraphTraversalDirection`): This can be
      either 'upstream' or 'downstream' or 'both' based on the
      direction in which to traverse the lineage graph. Default to
      'upstream'.
    * `levels` (`Int`): The number of hops to query in the lineage
      graph. Defaults to 1. (default: `1`)
    """

    get_reduced_downstream_lineage = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getReducedDownstreamLineage",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(general availability) Reduces a list of nodes to the most
    downstream ones

    Arguments:

    * `mcons` (`[String]!`): A list of nodes to check
    """

    get_external_source_paths_sample = sgqlc.types.Field(
        "TableSourceSample",
        graphql_name="getExternalSourcePathsSample",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("max_results", sgqlc.types.Arg(Int, graphql_name="maxResults", default=20)),
            )
        ),
    )
    """Gets sample of table sources, typically external files

    Arguments:

    * `mcon` (`String!`)None
    * `max_results` (`Int`)None (default: `20`)
    """

    get_tableau_workbook_count = sgqlc.types.Field(
        "TableauWorkbookCount",
        graphql_name="getTableauWorkbookCount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "bi_container_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="biContainerId", default=None
                    ),
                ),
            )
        ),
    )
    """Gets the number of workbooks in a Tableau instance.

    Arguments:

    * `bi_container_id` (`UUID!`): Monte Carlo UUID of the Tableau BI
      container
    """

    get_query_list = sgqlc.types.Field(
        sgqlc.types.list_of("QueryListResponse"),
        graphql_name="getQueryList",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryType", default=None
                    ),
                ),
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                (
                    "end_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="endTime", default=None
                    ),
                ),
                ("user_name", sgqlc.types.Arg(String, graphql_name="userName", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                (
                    "users",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="users", default=None
                    ),
                ),
                (
                    "sub_categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="subCategories", default=None
                    ),
                ),
                (
                    "sort_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="sortFields", default=None
                    ),
                ),
            )
        ),
    )
    """Gets the queries on this table according to query type

    Arguments:

    * `query_type` (`String!`): source (reads on the table) or
      destination (writes on this table)
    * `mcon` (`String!`): Monte Carlo object name
    * `start_time` (`DateTime!`): Filter for queries newer than this
    * `end_time` (`DateTime!`): Filter for queries older than this
    * `user_name` (`String`): [DEPRECATED] Filter by user name
    * `limit` (`Int`): Limit results returned
    * `offset` (`Int`): Offset when paging
    * `users` (`[String]`): Filter by users
    * `sub_categories` (`[String]`): Filter by subcategory
    * `sort_fields` (`[String]`): List of fields to sort by
    """

    get_query_by_id = sgqlc.types.Field(
        sgqlc.types.list_of("QueryDataObject"),
        graphql_name="getQueryById",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryId", default=None
                    ),
                ),
                (
                    "timestamp",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="timestamp", default=None
                    ),
                ),
                ("query_format", sgqlc.types.Arg(String, graphql_name="queryFormat", default=None)),
            )
        ),
    )
    """Gets the query by query ID

    Arguments:

    * `query_id` (`String!`): Query unique identifier
    * `timestamp` (`DateTime!`): Query execution time (can be reduced
      to day on which it ran)
    * `query_format` (`String`): 'raw' or 'base64' format
    """

    get_query_by_query_hash = sgqlc.types.Field(
        sgqlc.types.list_of("QueryDataObject"),
        graphql_name="getQueryByQueryHash",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query_hash",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryHash", default=None
                    ),
                ),
                (
                    "day",
                    sgqlc.types.Arg(sgqlc.types.non_null(Date), graphql_name="day", default=None),
                ),
                ("query_format", sgqlc.types.Arg(String, graphql_name="queryFormat", default=None)),
            )
        ),
    )
    """Gets the query by query hash

    Arguments:

    * `query_hash` (`String!`): The query_hash for which to fetch
      query data
    * `day` (`Date!`): The day on which the query ran
    * `query_format` (`String`): 'raw' or 'base64' format
    """

    get_query_data_by_query_hash = sgqlc.types.Field(
        sgqlc.types.list_of("QueryLogResponse"),
        graphql_name="getQueryDataByQueryHash",
        args=sgqlc.types.ArgDict(
            (
                (
                    "query_hash",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryHash", default=None
                    ),
                ),
                (
                    "day",
                    sgqlc.types.Arg(sgqlc.types.non_null(Date), graphql_name="day", default=None),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
            )
        ),
    )
    """Fetch query metadata for a single query for all daily occurrences

    Arguments:

    * `query_hash` (`String!`): The query_hash for which to fetch the
      queries
    * `day` (`Date!`): The day for which to fetch the query metadata
    * `limit` (`Int`): Limit results returned
    * `offset` (`Int`): Offset when paging
    """

    get_query_data = sgqlc.types.Field(
        sgqlc.types.list_of("QueryLogResponse"),
        graphql_name="getQueryData",
        args=sgqlc.types.ArgDict(
            (
                ("query_id", sgqlc.types.Arg(String, graphql_name="queryId", default=None)),
                ("query_hash", sgqlc.types.Arg(String, graphql_name="queryHash", default=None)),
                (
                    "day",
                    sgqlc.types.Arg(sgqlc.types.non_null(Date), graphql_name="day", default=None),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("group_id", sgqlc.types.Arg(String, graphql_name="groupId", default=None)),
            )
        ),
    )
    """Fetch query metadata for a single query for all daily occurrences

    Arguments:

    * `query_id` (`String`): The query_id for which to fetch the
      queries
    * `query_hash` (`String`): The query_hash for which to fetch the
      queries
    * `day` (`Date!`): The day for which to fetch the query metadata
    * `limit` (`Int`): Limit results returned
    * `offset` (`Int`): Offset when paging
    * `group_id` (`String`): Fetch queries that share the same
      group_id
    """

    get_query_log_hashes_that_affect_these_tables = sgqlc.types.Field(
        sgqlc.types.list_of("QueryLogHashes"),
        graphql_name="getQueryLogHashesThatAffectTheseTables",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fullTableIds", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "users",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="users", default=None
                    ),
                ),
                (
                    "query_characters",
                    sgqlc.types.Arg(Int, graphql_name="queryCharacters", default=None),
                ),
            )
        ),
    )
    """Get query log aggregates (AKA updates to these tables)

    Arguments:

    * `dw_id` (`UUID`): Warehouse the tables are contained in.
      Required when using fullTableIds
    * `full_table_ids` (`[String]`): Deprecated - use mcons. Ignored
      if mcons are present
    * `mcons` (`[String]`): List of mcons to get details for
    * `limit` (`Int`): Limit results returned
    * `offset` (`Int`): Offset when paging
    * `start_time` (`DateTime`): Filter for queries newer than this
    * `end_time` (`DateTime`): Filter for queries older than this
    * `users` (`[String]`): List of users to get details for
    * `query_characters` (`Int`): The number of characters in the
      query to return
    """

    get_related_users = sgqlc.types.Field(
        sgqlc.types.list_of("RelatedUserCount"),
        graphql_name="getRelatedUsers",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("query_type", sgqlc.types.Arg(String, graphql_name="queryType", default=None)),
            )
        ),
    )
    """Get users related to object

    Arguments:

    * `mcon` (`String!`): Monte Carlo object name
    * `start_time` (`DateTime`): Filter for queries newer than this.
      By default, endTime - 3 weeks
    * `end_time` (`DateTime`): Filter for queries older than this. By
      default, now
    * `query_type` (`String`): source (reads on the table) or
      destination (writes on this table)
    """

    get_lineage_node_properties = sgqlc.types.Field(
        sgqlc.types.list_of(NodeProperties),
        graphql_name="getLineageNodeProperties",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "node_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="nodeIds", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
            )
        ),
    )
    """Get properties (metadata) from nodes (DEPRECATED, use GetMetadata
    instead!)

    Arguments:

    * `dw_id` (`UUID`): Warehouse the asset is contained within. Not
      required when using an mcon as node id
    * `node_ids` (`[String]`): Deprecated - use mcon. Ignored if mcon
      is present
    * `mcons` (`[String]`): List of mcons to get properties for
    """

    get_digraph = sgqlc.types.Field(
        DirectedGraph,
        graphql_name="getDigraph",
        args=sgqlc.types.ArgDict(
            (
                (
                    "metadata_version",
                    sgqlc.types.Arg(String, graphql_name="metadataVersion", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `metadata_version` (`String`)None
    """

    get_custom_sql_output_sample = sgqlc.types.Field(
        CustomSQLOutputSample,
        graphql_name="getCustomSqlOutputSample",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "job_execution_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="jobExecutionUuid", default=None
                    ),
                ),
                (
                    "file_part_index",
                    sgqlc.types.Arg(Int, graphql_name="filePartIndex", default=None),
                ),
                ("fetch_all", sgqlc.types.Arg(Boolean, graphql_name="fetchAll", default=None)),
            )
        ),
    )
    """Retrieve output sample for custom SQL job execution

    Arguments:

    * `dw_id` (`UUID!`): Warehouse the custom SQL ran in
    * `job_execution_uuid` (`UUID!`): JobExecution to fetch the output
      sample for
    * `file_part_index` (`Int`): Sample file part index, if not
      specified, we'd use 0, the first file.
    * `fetch_all` (`Boolean`): Indicating whether to fetch all samples
      in one call. If this is true, thefile_part_index is ignored.
    """

    get_custom_sql_output_download = sgqlc.types.Field(
        CustomSQLOutputDownload,
        graphql_name="getCustomSqlOutputDownload",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
                (
                    "custom_rule_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="customRuleUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Runs custom sql rule and returns a download link for all results.

    Arguments:

    * `dw_id` (`UUID!`): Warehouse the custom SQL ran in
    * `custom_rule_uuid` (`UUID!`): Custom rule to run
    """

    get_fh_sampling = sgqlc.types.Field(
        MetricSampling,
        graphql_name="getFhSampling",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "event_created_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime),
                        graphql_name="eventCreatedTime",
                        default=None,
                    ),
                ),
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metric", default=None
                    ),
                ),
                ("dimension", sgqlc.types.Arg(String, graphql_name="dimension", default=None)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=True)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """Generates and/or runs a FH sampling query

    Arguments:

    * `monitor_uuid` (`UUID!`): Monitor uuid is used for creating the
      sampling query
    * `event_created_time` (`DateTime!`): When the anomaly occurred
    * `field` (`String!`): The field on which the anomaly was found
    * `metric` (`String!`): The metric which measured the anomaly
    * `dimension` (`String`): FH segment if segmented monitor
    * `dry_run` (`Boolean`): Generate sample query without running
      (default: `true`)
    * `limit` (`Int`): Limit results
    """

    get_fh_reproduction_query = sgqlc.types.Field(
        InvestigationQuery,
        graphql_name="getFhReproductionQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                (
                    "event_created_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime),
                        graphql_name="eventCreatedTime",
                        default=None,
                    ),
                ),
                (
                    "field",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="field", default=None
                    ),
                ),
                (
                    "metric",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="metric", default=None
                    ),
                ),
                ("dimension", sgqlc.types.Arg(String, graphql_name="dimension", default=None)),
                ("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=True)),
            )
        ),
    )
    """Generates a SQL query that will reproduce the anomalous data on a
    table

    Arguments:

    * `monitor_uuid` (`UUID!`): UUID of the monitor on which the
      anomaly occurred
    * `event_created_time` (`DateTime!`): When the anomaly occurred
    * `field` (`String!`): The field on which the anomaly was found
    * `metric` (`String!`): The metric which measured the anomaly
    * `dimension` (`String`): FH segment if segmented monitor
    * `dry_run` (`Boolean`): Generate sample query without running
      (default: `true`)
    """

    test_sql_query_part = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="testSqlQueryPart",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("query_part", sgqlc.types.Arg(String, graphql_name="queryPart", default=None)),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "data_source",
                    sgqlc.types.Arg(DataSourceUnionInput, graphql_name="dataSource", default=None),
                ),
            )
        ),
    )
    """Test part of query

    Arguments:

    * `dw_id` (`UUID`): Warehouse the table is contained in. Required
      when using a fullTableId
    * `full_table_id` (`String`): Deprecated - use mcon. Ignored if
      mcon is present
    * `mcon` (`String`): Mcon for table to get details for
    * `query_part` (`String`): Part of query (e.g. select options)
    * `connection_id` (`UUID`): Connection UUID to use for the query
    * `data_source` (`DataSourceUnionInput`): Target data source
    """

    test_sql_query_where_expression = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="testSqlQueryWhereExpression",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "where_expression",
                    sgqlc.types.Arg(String, graphql_name="whereExpression", default=None),
                ),
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "data_source",
                    sgqlc.types.Arg(DataSourceUnionInput, graphql_name="dataSource", default=None),
                ),
            )
        ),
    )
    """Test WHERE expression

    Arguments:

    * `dw_id` (`UUID`): Warehouse the table is contained in. Required
      when using a fullTableId
    * `full_table_id` (`String`): Deprecated - use mcon. Ignored if
      mcon is present
    * `mcon` (`String`): Mcon for table to get details for
    * `where_expression` (`String`): body of the where expression
      (without WHERE prefix)
    * `connection_id` (`UUID`): Connection UUID to use for the query
    * `data_source` (`DataSourceUnionInput`): Target data source
    """

    get_table_stats_v2 = sgqlc.types.Field(
        "TableStatsV2",
        graphql_name="getTableStatsV2",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("parent_mcon", sgqlc.types.Arg(String, graphql_name="parentMcon", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `parent_mcon` (`String`): Filter stats for tables by root mcon
    * `domain_id` (`UUID`): Filter by domain UUID
    """

    get_table_stats = sgqlc.types.Field(
        "TableStatsConnection",
        graphql_name="getTableStats",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "full_table_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="fullTableIds", default=None
                    ),
                ),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("parent_mcon", sgqlc.types.Arg(String, graphql_name="parentMcon", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `dw_id` (`UUID`): Filter by warehouse. Required when using a
      fullTableId
    * `full_table_ids` (`[String]`): Deprecated - use mcon. Ignored if
      mcon is present
    * `mcons` (`[String]`): Get stats for specific tables by mcon
    * `parent_mcon` (`String`): Filter stats for tables by parent mcon
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_resource = sgqlc.types.Field(
        "Resource",
        graphql_name="getResource",
        args=sgqlc.types.ArgDict(
            (
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
            )
        ),
    )
    """Retrieve a specific resource

    Arguments:

    * `uuid` (`UUID`): The resource id
    * `name` (`String`): The resource name
    """

    get_resources = sgqlc.types.Field(sgqlc.types.list_of("Resource"), graphql_name="getResources")
    """Retrieve all resources in an account"""

    get_table_fields_importance = sgqlc.types.Field(
        "TableFieldsImportance",
        graphql_name="getTableFieldsImportance",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
                (
                    "importance_score_cutoff",
                    sgqlc.types.Arg(Float, graphql_name="importanceScoreCutoff", default=None),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                (
                    "field_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(FieldType)),
                        graphql_name="fieldTypes",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `mcon` (`String!`)
    * `importance_score_cutoff` (`Float`)
    * `limit` (`Int`)
    * `field_types` (`[FieldType!]`): Filter to these field types
    """

    get_wildcard_templates = sgqlc.types.Field(
        "WildcardTemplates",
        graphql_name="getWildcardTemplates",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dw_id",
                    sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="dwId", default=None),
                ),
            )
        ),
    )
    """List of templates used for aggregating wildcard tables

    Arguments:

    * `dw_id` (`UUID!`): UUID of the warehouse to fetch templates for
    """

    run_sql_investigation_query = sgqlc.types.Field(
        "SQLResponse",
        graphql_name="runSqlInvestigationQuery",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
                ("variables", sgqlc.types.Arg(JSONString, graphql_name="variables", default=None)),
            )
        ),
    )
    """Arguments:

    * `dw_id` (`UUID`): warehouse UUID
    * `query` (`String`): Investigation query to run
    * `variables` (`JSONString`): variables and values to use
    """

    get_warehouse_connections = sgqlc.types.Field(
        sgqlc.types.list_of(Connection),
        graphql_name="getWarehouseConnections",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                (
                    "job_types",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="jobTypes", default=None
                    ),
                ),
            )
        ),
    )
    """Get connections of a warehouse.

    Arguments:

    * `warehouse_uuid` (`UUID!`): Warehouse UUID
    * `job_types` (`[String]`): Job types to filter connections
    """

    get_warehouse_tags_collection_setting = sgqlc.types.Field(
        "WarehouseTagsCollectionSetting",
        graphql_name="getWarehouseTagsCollectionSetting",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Returns if tags collection setting is enabled for a
    warehouse

    Arguments:

    * `warehouse_uuid` (`UUID!`): Warehouse UUID
    """

    get_lineage_node_types = sgqlc.types.Field(
        LineageNodeTypeStats,
        graphql_name="getLineageNodeTypes",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """(general availability) Counts of upstream and downstream nodes
    grouped by type

    Arguments:

    * `mcon` (`String!`): MCON for which to fetch the counts
    """

    get_common_fields = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getCommonFields",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
            )
        ),
    )
    """Get fields that are common across a set of tables.

    Arguments:

    * `mcons` (`[String]`): The tables to inspect. All tables must
      belong to the same warehouse.
    """

    get_common_fields_v2 = sgqlc.types.Field(
        "TableFields",
        graphql_name="getCommonFieldsV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
            )
        ),
    )
    """Get fields that are common across a set of tables.

    Arguments:

    * `mcons` (`[String]`): The tables to inspect. All tables must
      belong to the same warehouse.
    """

    get_tsa_availability = sgqlc.types.Field("TSAAvailability", graphql_name="getTsaAvailability")
    """(experimental) Get Troubleshooting Agent availability"""

    get_user_settings = sgqlc.types.Field(
        sgqlc.types.list_of("UserSettings"),
        graphql_name="getUserSettings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "keys",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="keys",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get user-specific settings. Return only the settings that have
    value.

    Arguments:

    * `keys` (`[String]!`): User setting's keys
    """

    get_shared_query = sgqlc.types.Field(
        "SharedQueryOutput",
        graphql_name="getSharedQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "key",
                    sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None),
                ),
            )
        ),
    )
    """(experimental) Get a shared API Explorer query

    Arguments:

    * `key` (`String!`): S3 object key of shared query file
    """

    get_user = sgqlc.types.Field("User", graphql_name="getUser")

    get_user_by_id = sgqlc.types.Field("User", graphql_name="getUserById")

    get_warehouses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Warehouse"))),
        graphql_name="getWarehouses",
        args=sgqlc.types.ArgDict(
            (("domain_uuid", sgqlc.types.Arg(UUID, graphql_name="domainUuid", default=None)),)
        ),
    )
    """(experimental) Get warehouses accessible to the current user

    Arguments:

    * `domain_uuid` (`UUID`): Filter warehouses by domain UUID
    """

    get_should_show_onboarding = sgqlc.types.Field(Boolean, graphql_name="getShouldShowOnboarding")
    """(experimental) Get whether the user should see the onboarding flow"""

    get_warehouse = sgqlc.types.Field(
        "Warehouse",
        graphql_name="getWarehouse",
        args=sgqlc.types.ArgDict(
            (("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),)
        ),
    )
    """Arguments:

    * `uuid` (`UUID`)None
    """

    get_collection_properties = sgqlc.types.Field(
        CollectionProperties,
        graphql_name="getCollectionProperties",
        args=sgqlc.types.ArgDict(
            (
                (
                    "region",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="region", default=None
                    ),
                ),
            )
        ),
    )
    """Get infrastructure properties for a new data collector deployment

    Arguments:

    * `region` (`String!`): AWS region
    """

    get_table = sgqlc.types.Field(
        "WarehouseTable",
        graphql_name="getTable",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
            )
        ),
    )
    """Get information about a table

    Arguments:

    * `dw_id` (`UUID`): Warehouse the table is contained in. Required
      when using a fullTableId
    * `full_table_id` (`String`): Deprecated - use mcon. Ignored if
      mcon is present
    * `mcon` (`String`): Mcon for table to get details for
    """

    get_tables = sgqlc.types.Field(
        "WarehouseTableConnection",
        graphql_name="getTables",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "status",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="status", default=None
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("table_id", sgqlc.types.Arg(String, graphql_name="tableId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("warehouse", sgqlc.types.Arg(ID, graphql_name="warehouse", default=None)),
                (
                    "discovered_time",
                    sgqlc.types.Arg(DateTime, graphql_name="discoveredTime", default=None),
                ),
                (
                    "friendly_name",
                    sgqlc.types.Arg(String, graphql_name="friendlyName", default=None),
                ),
                ("location", sgqlc.types.Arg(String, graphql_name="location", default=None)),
                ("project_name", sgqlc.types.Arg(String, graphql_name="projectName", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("table_type", sgqlc.types.Arg(String, graphql_name="tableType", default=None)),
                (
                    "is_encrypted",
                    sgqlc.types.Arg(Boolean, graphql_name="isEncrypted", default=None),
                ),
                (
                    "created_time",
                    sgqlc.types.Arg(DateTime, graphql_name="createdTime", default=None),
                ),
                (
                    "last_modified",
                    sgqlc.types.Arg(DateTime, graphql_name="lastModified", default=None),
                ),
                ("view_query", sgqlc.types.Arg(String, graphql_name="viewQuery", default=None)),
                (
                    "view_is_materialized",
                    sgqlc.types.Arg(Boolean, graphql_name="viewIsMaterialized", default=None),
                ),
                ("path", sgqlc.types.Arg(String, graphql_name="path", default=None)),
                ("priority", sgqlc.types.Arg(Int, graphql_name="priority", default=None)),
                ("tracked", sgqlc.types.Arg(Boolean, graphql_name="tracked", default=None)),
                (
                    "dynamic_table",
                    sgqlc.types.Arg(Boolean, graphql_name="dynamicTable", default=None),
                ),
                ("is_deleted", sgqlc.types.Arg(Boolean, graphql_name="isDeleted", default=None)),
                ("deleted_at", sgqlc.types.Arg(DateTime, graphql_name="deletedAt", default=None)),
                (
                    "last_observed",
                    sgqlc.types.Arg(DateTime, graphql_name="lastObserved", default=None),
                ),
                ("is_excluded", sgqlc.types.Arg(Boolean, graphql_name="isExcluded", default=None)),
                (
                    "is_monitored",
                    sgqlc.types.Arg(Boolean, graphql_name="isMonitored", default=None),
                ),
                (
                    "data_provider",
                    sgqlc.types.Arg(String, graphql_name="dataProvider", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "importance_score",
                    sgqlc.types.Arg(Float, graphql_name="importanceScore", default=None),
                ),
                (
                    "is_important",
                    sgqlc.types.Arg(Boolean, graphql_name="isImportant", default=None),
                ),
                (
                    "last_activity",
                    sgqlc.types.Arg(DateTime, graphql_name="lastActivity", default=None),
                ),
                ("last_read", sgqlc.types.Arg(DateTime, graphql_name="lastRead", default=None)),
                ("last_write", sgqlc.types.Arg(DateTime, graphql_name="lastWrite", default=None)),
                (
                    "last_volume_change",
                    sgqlc.types.Arg(DateTime, graphql_name="lastVolumeChange", default=None),
                ),
                (
                    "importance_score_is_custom",
                    sgqlc.types.Arg(Boolean, graphql_name="importanceScoreIsCustom", default=None),
                ),
                (
                    "is_important_is_custom",
                    sgqlc.types.Arg(Boolean, graphql_name="isImportantIsCustom", default=None),
                ),
                (
                    "last_observed__gt",
                    sgqlc.types.Arg(DateTime, graphql_name="lastObserved_Gt", default=None),
                ),
                (
                    "freshness_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="freshnessAnomaly", default=None),
                ),
                (
                    "size_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="sizeAnomaly", default=None),
                ),
                (
                    "metric_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="metricAnomaly", default=None),
                ),
                (
                    "freshness_size_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="freshnessSizeAnomaly", default=None),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """Get tables in account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `search` (`String`): Filter by partial asset names (e.g.
      dataset)
    * `status` (`[String]`): Filter by table statuses
    * `domain_id` (`UUID`): Filter by domain UUID
    * `mcons` (`[String]`): Filter by a list of mcons
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `table_id` (`String`)None
    * `full_table_id` (`String`)None
    * `warehouse` (`ID`)None
    * `discovered_time` (`DateTime`)None
    * `friendly_name` (`String`)None
    * `location` (`String`)None
    * `project_name` (`String`)None
    * `dataset` (`String`)None
    * `description` (`String`)None
    * `table_type` (`String`)None
    * `is_encrypted` (`Boolean`)None
    * `created_time` (`DateTime`)None
    * `last_modified` (`DateTime`)None
    * `view_query` (`String`)None
    * `view_is_materialized` (`Boolean`)None
    * `path` (`String`)None
    * `priority` (`Int`)None
    * `tracked` (`Boolean`)None
    * `dynamic_table` (`Boolean`)None
    * `is_deleted` (`Boolean`)None
    * `deleted_at` (`DateTime`)None
    * `last_observed` (`DateTime`)None
    * `is_excluded` (`Boolean`)None
    * `is_monitored` (`Boolean`)None
    * `data_provider` (`String`)None
    * `mcon` (`String`)None
    * `importance_score` (`Float`)None
    * `is_important` (`Boolean`)None
    * `last_activity` (`DateTime`)None
    * `last_read` (`DateTime`)None
    * `last_write` (`DateTime`)None
    * `last_volume_change` (`DateTime`)None
    * `importance_score_is_custom` (`Boolean`)None
    * `is_important_is_custom` (`Boolean`)None
    * `last_observed__gt` (`DateTime`)None
    * `freshness_anomaly` (`Boolean`)None
    * `size_anomaly` (`Boolean`)None
    * `metric_anomaly` (`Boolean`)None
    * `freshness_size_anomaly` (`Boolean`)None
    * `order_by` (`String`): Ordering
    """

    get_tables_health = sgqlc.types.Field(
        "WarehouseTableHealthConnection",
        graphql_name="getTablesHealth",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "domain_ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(UUID), graphql_name="domainIds", default=None
                    ),
                ),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
                (
                    "table_contains",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableContains", default=None
                    ),
                ),
                (
                    "tags_contains",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tagsContains", default=None
                    ),
                ),
                (
                    "tag_key_value_pairs",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(TagKeyValuePairInput),
                        graphql_name="tagKeyValuePairs",
                        default=None,
                    ),
                ),
                (
                    "key_assets_only",
                    sgqlc.types.Arg(Boolean, graphql_name="keyAssetsOnly", default=None),
                ),
                (
                    "has_incidents_only",
                    sgqlc.types.Arg(Boolean, graphql_name="hasIncidentsOnly", default=None),
                ),
                (
                    "has_alerts_only",
                    sgqlc.types.Arg(Boolean, graphql_name="hasAlertsOnly", default=None),
                ),
                (
                    "has_incidents_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="hasIncidentsStartTime", default=None),
                ),
                (
                    "has_alerts_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="hasAlertsStartTime", default=None),
                ),
                (
                    "has_incidents_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="hasIncidentsEndTime", default=None),
                ),
                (
                    "has_alerts_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="hasAlertsEndTime", default=None),
                ),
                (
                    "has_incidents_include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasIncidentsIncludeFeedback",
                        default=None,
                    ),
                ),
                (
                    "has_alerts_include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasAlertsIncludeFeedback",
                        default=None,
                    ),
                ),
                (
                    "has_incidents_exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasIncidentsExcludeFeedback",
                        default=None,
                    ),
                ),
                (
                    "has_alerts_exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasAlertsExcludeFeedback",
                        default=None,
                    ),
                ),
                (
                    "has_incidents_include_normalized",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="hasIncidentsIncludeNormalized", default=None
                    ),
                ),
                (
                    "has_alerts_include_normalized",
                    sgqlc.types.Arg(
                        Boolean, graphql_name="hasAlertsIncludeNormalized", default=None
                    ),
                ),
                (
                    "has_incidents_severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasIncidentsSeverities",
                        default=None,
                    ),
                ),
                (
                    "has_alerts_severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasAlertsSeverities",
                        default=None,
                    ),
                ),
                (
                    "has_incidents_priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasIncidentsPriorities",
                        default=None,
                    ),
                ),
                (
                    "has_alerts_priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String),
                        graphql_name="hasAlertsPriorities",
                        default=None,
                    ),
                ),
                (
                    "incident_categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="incidentCategories",
                        default=None,
                    ),
                ),
                (
                    "alert_categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="alertCategories",
                        default=None,
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("table_id", sgqlc.types.Arg(String, graphql_name="tableId", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("warehouse", sgqlc.types.Arg(ID, graphql_name="warehouse", default=None)),
                (
                    "discovered_time",
                    sgqlc.types.Arg(DateTime, graphql_name="discoveredTime", default=None),
                ),
                (
                    "friendly_name",
                    sgqlc.types.Arg(String, graphql_name="friendlyName", default=None),
                ),
                ("location", sgqlc.types.Arg(String, graphql_name="location", default=None)),
                ("project_name", sgqlc.types.Arg(String, graphql_name="projectName", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("table_type", sgqlc.types.Arg(String, graphql_name="tableType", default=None)),
                (
                    "is_encrypted",
                    sgqlc.types.Arg(Boolean, graphql_name="isEncrypted", default=None),
                ),
                (
                    "created_time",
                    sgqlc.types.Arg(DateTime, graphql_name="createdTime", default=None),
                ),
                (
                    "last_modified",
                    sgqlc.types.Arg(DateTime, graphql_name="lastModified", default=None),
                ),
                ("view_query", sgqlc.types.Arg(String, graphql_name="viewQuery", default=None)),
                (
                    "view_is_materialized",
                    sgqlc.types.Arg(Boolean, graphql_name="viewIsMaterialized", default=None),
                ),
                ("path", sgqlc.types.Arg(String, graphql_name="path", default=None)),
                ("priority", sgqlc.types.Arg(Int, graphql_name="priority", default=None)),
                ("tracked", sgqlc.types.Arg(Boolean, graphql_name="tracked", default=None)),
                (
                    "dynamic_table",
                    sgqlc.types.Arg(Boolean, graphql_name="dynamicTable", default=None),
                ),
                ("is_deleted", sgqlc.types.Arg(Boolean, graphql_name="isDeleted", default=None)),
                ("deleted_at", sgqlc.types.Arg(DateTime, graphql_name="deletedAt", default=None)),
                (
                    "last_observed",
                    sgqlc.types.Arg(DateTime, graphql_name="lastObserved", default=None),
                ),
                ("is_excluded", sgqlc.types.Arg(Boolean, graphql_name="isExcluded", default=None)),
                (
                    "is_monitored",
                    sgqlc.types.Arg(Boolean, graphql_name="isMonitored", default=None),
                ),
                (
                    "data_provider",
                    sgqlc.types.Arg(String, graphql_name="dataProvider", default=None),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                (
                    "importance_score",
                    sgqlc.types.Arg(Float, graphql_name="importanceScore", default=None),
                ),
                (
                    "is_important",
                    sgqlc.types.Arg(Boolean, graphql_name="isImportant", default=None),
                ),
                (
                    "last_activity",
                    sgqlc.types.Arg(DateTime, graphql_name="lastActivity", default=None),
                ),
                ("last_read", sgqlc.types.Arg(DateTime, graphql_name="lastRead", default=None)),
                ("last_write", sgqlc.types.Arg(DateTime, graphql_name="lastWrite", default=None)),
                (
                    "last_volume_change",
                    sgqlc.types.Arg(DateTime, graphql_name="lastVolumeChange", default=None),
                ),
                (
                    "importance_score_is_custom",
                    sgqlc.types.Arg(Boolean, graphql_name="importanceScoreIsCustom", default=None),
                ),
                (
                    "is_important_is_custom",
                    sgqlc.types.Arg(Boolean, graphql_name="isImportantIsCustom", default=None),
                ),
                (
                    "freshness_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="freshnessAnomaly", default=None),
                ),
                (
                    "size_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="sizeAnomaly", default=None),
                ),
                (
                    "metric_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="metricAnomaly", default=None),
                ),
                (
                    "freshness_size_anomaly",
                    sgqlc.types.Arg(Boolean, graphql_name="freshnessSizeAnomaly", default=None),
                ),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """Get tables health in account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `search` (`String`): Filter by partial asset names (e.g.
      dataset)
    * `domain_id` (`UUID`): Filter by domain UUID - Use domain_ids
      field instead
    * `domain_ids` (`[UUID]`): Filter by domain UUIDs
    * `table_mcons` (`[String]`): List of table MCONS to filter the
      result
    * `table_contains` (`[String]`): List of terms to filter the
      result on full name (project/schema/name) of the tables
    * `tags_contains` (`[String]`): List of terms to filter the result
      on tags (both tag keys and values)
    * `tag_key_value_pairs` (`[TagKeyValuePairInput]`): Filter by tag
      key values
    * `key_assets_only` (`Boolean`): Filter by key assets only
    * `has_incidents_only` (`Boolean`): Filter by tables that have
      incidents. Deprecated, use hasAlertsOnly instead.
    * `has_alerts_only` (`Boolean`): Filter by tables that have alerts
    * `has_incidents_start_time` (`DateTime`): Filter tables without
      incidents newer than this. Deprecated, use hasAlertsStartTime
      instead.
    * `has_alerts_start_time` (`DateTime`): Filter tables without
      alerts newer than this
    * `has_incidents_end_time` (`DateTime`): Filter tables without
      incidents older than this. Deprecated, use hasAlertsEndTime
      instead.
    * `has_alerts_end_time` (`DateTime`): Filter tables without alerts
      older than this
    * `has_incidents_include_feedback` (`[String]`): Filter tables
      without incidents with user feedback. Deprecated, use
      hasAlertsIncludeFeedback instead.
    * `has_alerts_include_feedback` (`[String]`): Filter tables
      without alerts with user feedback
    * `has_incidents_exclude_feedback` (`[String]`): Filter tables
      without incidents excluding user feedback. Deprecated, use
      hasAlertsExcludeFeedback instead.
    * `has_alerts_exclude_feedback` (`[String]`): Filter tables
      without alerts excluding user feedback
    * `has_incidents_include_normalized` (`Boolean`): Filter tables
      without incidents excluding normalized incidents if False is
      indicate. Deprecated, use hasAlertsIncludeNormalized instead.
    * `has_alerts_include_normalized` (`Boolean`): Filter tables
      without alerts excluding normalized incidents if False is
      indicate
    * `has_incidents_severities` (`[String]`): Filter tables without
      incidents with severity. Deprecated, use hasAlertsSeverities
      instead.
    * `has_alerts_severities` (`[String]`): Filter tables without
      alerts with severity
    * `has_incidents_priorities` (`[String]`): Filter tables without
      incidents with priority. Deprecated, use hasAlertsPriorities
      instead.
    * `has_alerts_priorities` (`[String]`): Filter tables without
      alerts with priority
    * `incident_categories` (`[IncidentCategory]`): Include only
      selected incident categories. Or all categories if not
      specified. Deprecated, use alertCategories instead.
    * `alert_categories` (`[IncidentCategory]`): Include only selected
      alert categories. Or all categories if not specified.
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `table_id` (`String`)None
    * `full_table_id` (`String`)None
    * `warehouse` (`ID`)None
    * `discovered_time` (`DateTime`)None
    * `friendly_name` (`String`)None
    * `location` (`String`)None
    * `project_name` (`String`)None
    * `dataset` (`String`)None
    * `description` (`String`)None
    * `table_type` (`String`)None
    * `is_encrypted` (`Boolean`)None
    * `created_time` (`DateTime`)None
    * `last_modified` (`DateTime`)None
    * `view_query` (`String`)None
    * `view_is_materialized` (`Boolean`)None
    * `path` (`String`)None
    * `priority` (`Int`)None
    * `tracked` (`Boolean`)None
    * `dynamic_table` (`Boolean`)None
    * `is_deleted` (`Boolean`)None
    * `deleted_at` (`DateTime`)None
    * `last_observed` (`DateTime`)None
    * `is_excluded` (`Boolean`)None
    * `is_monitored` (`Boolean`)None
    * `data_provider` (`String`)None
    * `mcon` (`String`)None
    * `importance_score` (`Float`)None
    * `is_important` (`Boolean`)None
    * `last_activity` (`DateTime`)None
    * `last_read` (`DateTime`)None
    * `last_write` (`DateTime`)None
    * `last_volume_change` (`DateTime`)None
    * `importance_score_is_custom` (`Boolean`)None
    * `is_important_is_custom` (`Boolean`)None
    * `freshness_anomaly` (`Boolean`)None
    * `size_anomaly` (`Boolean`)None
    * `metric_anomaly` (`Boolean`)None
    * `freshness_size_anomaly` (`Boolean`)None
    * `order_by` (`String`): Ordering
    """

    get_bq_projects = sgqlc.types.Field(
        sgqlc.types.list_of(BigQueryProject),
        graphql_name="getBqProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "credentials_key",
                    sgqlc.types.Arg(String, graphql_name="credentialsKey", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `credentials_key` (`String`)None
    """

    get_slack_oauth_url = sgqlc.types.Field(
        "SlackOauthUrlResponse",
        graphql_name="getSlackOauthUrl",
        args=sgqlc.types.ArgDict(
            (
                (
                    "slack_app_type",
                    sgqlc.types.Arg(SlackAppType, graphql_name="slackAppType", default=None),
                ),
            )
        ),
    )
    """Returns a Slack OAuth URL

    Arguments:

    * `slack_app_type` (`SlackAppType`): Slack app type
    """

    get_slack_channels = sgqlc.types.Field(
        "SlackChannelResponse",
        graphql_name="getSlackChannels",
        args=sgqlc.types.ArgDict(
            (
                (
                    "exclude_archived",
                    sgqlc.types.Arg(Boolean, graphql_name="excludeArchived", default=None),
                ),
                (
                    "ignore_cached",
                    sgqlc.types.Arg(Boolean, graphql_name="ignoreCached", default=None),
                ),
                ("team_id", sgqlc.types.Arg(String, graphql_name="teamId", default=None)),
            )
        ),
    )
    """Arguments:

    * `exclude_archived` (`Boolean`): Specify whether to include
      archived Slack Channels
    * `ignore_cached` (`Boolean`): Specify whether to ignore the
      cached versions and attempt to pull directly from Slack API.
    * `team_id` (`String`): Specify a team ID to filter Slack Channels
      by, If this value is not set then slack channels with empty
      team_id will be returned.
    """

    get_slack_channels_v2 = sgqlc.types.Field(
        "SlackChannelV2Connection",
        graphql_name="getSlackChannelsV2",
        args=sgqlc.types.ArgDict(
            (
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("name__iexact", sgqlc.types.Arg(String, graphql_name="name_Iexact", default=None)),
                (
                    "name__icontains",
                    sgqlc.types.Arg(String, graphql_name="name_Icontains", default=None),
                ),
                (
                    "name__istartswith",
                    sgqlc.types.Arg(String, graphql_name="name_Istartswith", default=None),
                ),
                (
                    "team_id__iexact",
                    sgqlc.types.Arg(String, graphql_name="teamId_Iexact", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `order_by` (`String`): Ordering
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `name__iexact` (`String`)None
    * `name__icontains` (`String`)None
    * `name__istartswith` (`String`)None
    * `team_id__iexact` (`String`)None
    """

    get_projects = sgqlc.types.Field(
        ProjectConnection,
        graphql_name="getProjects",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "include_table_count",
                    sgqlc.types.Arg(Boolean, graphql_name="includeTableCount", default=False),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Get projects by UUID

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `search` (`String`): Filter by a project
    * `domain_id` (`UUID`): Filter by domain UUID
    * `include_table_count` (`Boolean`): Include table count for each
      project (default: `false`)
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `project` (`String`)None
    * `mcon` (`String`)None
    * `uuid` (`UUID`)None
    """

    get_datasets_by_uuid = sgqlc.types.Field(
        sgqlc.types.list_of("Dataset"),
        graphql_name="getDatasetsByUuid",
        args=sgqlc.types.ArgDict(
            (
                (
                    "dataset_uuids",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(UUID)),
                        graphql_name="datasetUuids",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get datasets by UUID

    Arguments:

    * `dataset_uuids` (`[UUID]!`)None
    """

    get_datasets = sgqlc.types.Field(
        DatasetConnection,
        graphql_name="getDatasets",
        args=sgqlc.types.ArgDict(
            (
                ("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "allow_search_on_project",
                    sgqlc.types.Arg(Boolean, graphql_name="allowSearchOnProject", default=None),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
                (
                    "include_table_count",
                    sgqlc.types.Arg(Boolean, graphql_name="includeTableCount", default=False),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
            )
        ),
    )
    """Get datasets in the account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    * `search` (`String`): Filter by a dataset
    * `allow_search_on_project` (`Boolean`): Apply search filter on
      project name
    * `domain_id` (`UUID`): Filter by domain UUID
    * `include_table_count` (`Boolean`): Include table count for each
      dataset (default: `false`)
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `dataset` (`String`)None
    * `project` (`String`)None
    """

    get_field_bi_lineage = sgqlc.types.Field(
        sgqlc.types.list_of(FieldDownstreamBi),
        graphql_name="getFieldBiLineage",
        args=sgqlc.types.ArgDict(
            (
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
                ("field_name", sgqlc.types.Arg(String, graphql_name="fieldName", default=None)),
                (
                    "last_seen_range_start",
                    sgqlc.types.Arg(DateTime, graphql_name="lastSeenRangeStart", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `full_table_id` (`String`)None
    * `field_name` (`String`)None
    * `last_seen_range_start` (`DateTime`)None
    """

    get_event_muting_rules = sgqlc.types.Field(
        sgqlc.types.list_of(EventMutingRule),
        graphql_name="getEventMutingRules",
        args=sgqlc.types.ArgDict(
            (("dw_id", sgqlc.types.Arg(UUID, graphql_name="dwId", default=None)),)
        ),
    )
    """Get muting rules in the account

    Arguments:

    * `dw_id` (`UUID`): Filter by a specific warehouse
    """

    get_users_in_account = sgqlc.types.Field(
        "UserConnection",
        graphql_name="getUsersInAccount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "roles",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="roles", default=None
                    ),
                ),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "order_by",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="orderBy", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("email", sgqlc.types.Arg(String, graphql_name="email", default=None)),
                ("first_name", sgqlc.types.Arg(String, graphql_name="firstName", default=None)),
                ("last_name", sgqlc.types.Arg(String, graphql_name="lastName", default=None)),
                ("role", sgqlc.types.Arg(String, graphql_name="role", default=None)),
            )
        ),
    )
    """Arguments:

    * `roles` (`[String]`): Filter by user roles
    * `search` (`String`): Filter by first name, last name or email
      address
    * `order_by` (`[String]`): Order by fields. Use camelCase and '-'
      for desc. e.g. ['email', '-role']
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `email` (`String`)None
    * `first_name` (`String`)None
    * `last_name` (`String`)None
    * `role` (`String`)None
    """

    get_users_basic_info = sgqlc.types.Field(
        "UserBasicInfoConnection",
        graphql_name="getUsersBasicInfo",
        args=sgqlc.types.ArgDict(
            (
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get ids, emails and names of all users in account

    Arguments:

    * `search` (`String`): Filter by first name, last name or email
      address
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_invites_in_account = sgqlc.types.Field(
        "UserInviteConnection",
        graphql_name="getInvitesInAccount",
        args=sgqlc.types.ArgDict(
            (
                (
                    "roles",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="roles", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
            )
        ),
    )
    """Arguments:

    * `roles` (`[String]`): Filter by user role membership
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `state` (`String`)None
    """

    get_token_metadata = sgqlc.types.Field(
        sgqlc.types.list_of("TokenMetadata"),
        graphql_name="getTokenMetadata",
        args=sgqlc.types.ArgDict(
            (
                (
                    "index",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AccessKeyIndexEnum), graphql_name="index", default=None
                    ),
                ),
                (
                    "is_service_api_token",
                    sgqlc.types.Arg(Boolean, graphql_name="isServiceApiToken", default=False),
                ),
            )
        ),
    )
    """Retrieve access token metadata for current user or account

    Arguments:

    * `index` (`AccessKeyIndexEnum!`): Specifies which metadata index
      to use
    * `is_service_api_token` (`Boolean`): Filter by token type.
      (default: `false`)
    """

    get_integration_keys = sgqlc.types.Field(
        sgqlc.types.list_of(IntegrationKeyMetadata),
        graphql_name="getIntegrationKeys",
        args=sgqlc.types.ArgDict(
            (
                ("scope", sgqlc.types.Arg(String, graphql_name="scope", default=None)),
                ("resource_uuid", sgqlc.types.Arg(UUID, graphql_name="resourceUuid", default=None)),
            )
        ),
    )
    """Retrieve integration keys in the current user's account

    Arguments:

    * `scope` (`String`): Optional scope to filter keys by
    * `resource_uuid` (`UUID`): Optional, return only keys including
      this resource id
    """

    test_existing_connection = sgqlc.types.Field(
        "TestConnectionResponse",
        graphql_name="testExistingConnection",
        args=sgqlc.types.ArgDict(
            (("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),)
        ),
    )
    """Test an existing connection's credentials against the account's
    data collector

    Arguments:

    * `connection_id` (`UUID`): An existing connection's UUID
    """

    test_telnet_connection = sgqlc.types.Field(
        "TestConnectionResponse",
        graphql_name="testTelnetConnection",
        args=sgqlc.types.ArgDict(
            (
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
                ("port", sgqlc.types.Arg(Int, graphql_name="port", default=None)),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "ignore_agent",
                    sgqlc.types.Arg(Boolean, graphql_name="ignoreAgent", default=None),
                ),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Checks if telnet connection is usable.

    Arguments:

    * `host` (`String`): Host to check
    * `port` (`Int`): Port to check
    * `timeout` (`Int`): Timeout in seconds
    * `dc_id` (`UUID`): [Deprecated] Use serviceUuid instead
    * `ignore_agent` (`Boolean`): Perform the DNS Lookup in the
      platform service, even if a remote agent is configured
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    test_tcp_open_connection = sgqlc.types.Field(
        "TestConnectionResponse",
        graphql_name="testTcpOpenConnection",
        args=sgqlc.types.ArgDict(
            (
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
                ("port", sgqlc.types.Arg(Int, graphql_name="port", default=None)),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "ignore_agent",
                    sgqlc.types.Arg(Boolean, graphql_name="ignoreAgent", default=None),
                ),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Tests if a destination exists and accepts requests. Opens a TCP
    Socket to a specific port.

    Arguments:

    * `host` (`String`): Host to check
    * `port` (`Int`): Port to check
    * `timeout` (`Int`): Timeout in seconds
    * `dc_id` (`UUID`): [Deprecated] Use serviceUuid instead
    * `ignore_agent` (`Boolean`): Perform the DNS Lookup in the
      platform service, even if a remote agent is configured
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    test_dns_lookup = sgqlc.types.Field(
        "TestConnectionResponse",
        graphql_name="testDnsLookup",
        args=sgqlc.types.ArgDict(
            (
                ("host", sgqlc.types.Arg(String, graphql_name="host", default=None)),
                ("port", sgqlc.types.Arg(Int, graphql_name="port", default=None)),
                (
                    "ignore_agent",
                    sgqlc.types.Arg(Boolean, graphql_name="ignoreAgent", default=None),
                ),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """Performs a DNS lookup for the specified host name

    Arguments:

    * `host` (`String`): Host to check
    * `port` (`Int`): Optional port to use
    * `ignore_agent` (`Boolean`): Perform the DNS Lookup in the
      platform service, even if a remote agent is configured
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    test_http_connection = sgqlc.types.Field(
        "TestConnectionResponse",
        graphql_name="testHttpConnection",
        args=sgqlc.types.ArgDict(
            (
                ("url", sgqlc.types.Arg(String, graphql_name="url", default=None)),
                (
                    "include_response",
                    sgqlc.types.Arg(Boolean, graphql_name="includeResponse", default=None),
                ),
                (
                    "ignore_agent",
                    sgqlc.types.Arg(Boolean, graphql_name="ignoreAgent", default=None),
                ),
                ("timeout", sgqlc.types.Arg(Int, graphql_name="timeout", default=None)),
                ("service_uuid", sgqlc.types.Arg(UUID, graphql_name="serviceUuid", default=None)),
            )
        ),
    )
    """(experimental) Executes a GET request to test access to the
    specified URL from the platform service

    Arguments:

    * `url` (`String`): URL to test
    * `include_response` (`Boolean`): Include the response from the
      URL, defaults to false
    * `ignore_agent` (`Boolean`): Executes the request in the platform
      service, even if a remote agent is configured
    * `timeout` (`Int`): Optional timeout to use (in seconds),
      defaults to 10
    * `service_uuid` (`UUID`): Platform Service UUID. To disambiguate
      accounts with multiple services
    """

    test_notification_integration = sgqlc.types.Field(
        Boolean,
        graphql_name="testNotificationIntegration",
        args=sgqlc.types.ArgDict(
            (("setting_id", sgqlc.types.Arg(UUID, graphql_name="settingId", default=None)),)
        ),
    )
    """Tests an integration is reachable by sending a sample alert. Note
    - rules are not evaluated.

    Arguments:

    * `setting_id` (`UUID`): UUID for the notification setting.
    """

    get_databricks_warehouse_info = sgqlc.types.Field(
        DatabricksWarehouseResponse,
        graphql_name="getDatabricksWarehouseInfo",
        args=sgqlc.types.ArgDict(
            (
                ("connection_id", sgqlc.types.Arg(UUID, graphql_name="connectionId", default=None)),
                (
                    "connection_config",
                    sgqlc.types.Arg(
                        DatabricksSqlWarehouseConnectionInput,
                        graphql_name="connectionConfig",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Get the state of the databricks warehouse.

    Arguments:

    * `connection_id` (`UUID`): A Databricks connection UUID.
    * `connection_config` (`DatabricksSqlWarehouseConnectionInput`):
      Connection config for new Databricks SQL Warehouse connection
    """

    validate_connection_type = sgqlc.types.Field(
        Boolean,
        graphql_name="validateConnectionType",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="warehouseType", default=None
                    ),
                ),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
            )
        ),
    )
    """Validate that the connection type can be added to the warehouse
    type

    Arguments:

    * `warehouse_type` (`String!`): The type of the warehouse to add
      the connection to
    * `connection_type` (`String!`): The type of the connection to add
    """

    get_event_onboarding_data = sgqlc.types.Field(
        EventOnbardingConfig, graphql_name="getEventOnboardingData"
    )

    get_etl_containers = sgqlc.types.Field(
        sgqlc.types.list_of(EtlContainer), graphql_name="getEtlContainers"
    )
    """Retrieve the list of ETL containers in the current user's account"""

    get_account_feature_flag_status = sgqlc.types.Field(
        Boolean,
        graphql_name="getAccountFeatureFlagStatus",
        args=sgqlc.types.ArgDict(
            (
                (
                    "feature",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="feature", default=None
                    ),
                ),
            )
        ),
    )
    """Returns feature flag state

    Arguments:

    * `feature` (`String!`): Name of the feature flag
    """

    get_api_usage = sgqlc.types.Field(
        ApiUsageResponse,
        graphql_name="getApiUsage",
        args=sgqlc.types.ArgDict(
            (
                ("start_date", sgqlc.types.Arg(Date, graphql_name="startDate", default=None)),
                ("end_date", sgqlc.types.Arg(Date, graphql_name="endDate", default=None)),
            )
        ),
    )
    """(experimental) Get API Gateway usage data for the account's API
    key

    Arguments:

    * `start_date` (`Date`): Start date for the usage query (defaults
      to current date)
    * `end_date` (`Date`): End date for the usage query (defaults to
      current date)
    """

    get_tables_upstream_counts = sgqlc.types.Field(
        sgqlc.types.list_of("TableUpstreamData"),
        graphql_name="getTablesUpstreamCounts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(String)),
                        graphql_name="mcons",
                        default=None,
                    ),
                ),
                ("domain_id", sgqlc.types.Arg(UUID, graphql_name="domainId", default=None)),
            )
        ),
    )
    """Fetch data about tables upstream status

    Arguments:

    * `mcons` (`[String]!`): List of table MCONS to filter the result
    * `domain_id` (`UUID`): Filter by domain UUID
    """

    get_tutorial_state = sgqlc.types.Field(
        sgqlc.types.list_of("UserTutorial"),
        graphql_name="getTutorialState",
        args=sgqlc.types.ArgDict(
            (("tutorial_name", sgqlc.types.Arg(String, graphql_name="tutorialName", default=None)),)
        ),
    )
    """(experimental) Fetches stages and status for tutorial

    Arguments:

    * `tutorial_name` (`String`): The name of the tutorial being
      queried
    """

    get_data_lake_catalog_mappings = sgqlc.types.Field(
        CatalogMappings,
        graphql_name="getDataLakeCatalogMappings",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get catalog mappings for a connection

    Arguments:

    * `connection_uuid` (`UUID!`): Connection UUID
    """

    get_supported_validations_v2 = sgqlc.types.Field(
        "SupportedValidationsResponse",
        graphql_name="getSupportedValidationsV2",
        args=sgqlc.types.ArgDict(
            (
                ("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),
                (
                    "connection_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="connectionType", default=None
                    ),
                ),
                ("scope", sgqlc.types.Arg(String, graphql_name="scope", default=None)),
            )
        ),
    )
    """Arguments:

    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors.
    * `connection_type` (`String!`): The type of connection to query
      supported validations for.
    * `scope` (`String`): The scope of validations to return
    """

    get_supported_table_validations = sgqlc.types.Field(
        "SupportedTableValidationsResponse",
        graphql_name="getSupportedTableValidations",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `connection_id` (`UUID!`): UUID of the connection to check for
      supported table validations.
    """

    validate_data_asset_access = sgqlc.types.Field(
        "ValidateDataAssetAccessResponse",
        graphql_name="validateDataAssetAccess",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "validation_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="validationNames", default=None
                    ),
                ),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("asset_id", sgqlc.types.Arg(String, graphql_name="assetId", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                ("asset_name", sgqlc.types.Arg(String, graphql_name="assetName", default=None)),
                (
                    "asset_type",
                    sgqlc.types.Arg(DataAssetTypeEnum, graphql_name="assetType", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `connection_id` (`UUID!`): The connection UUID
    * `validation_names` (`[String]`): Name of the table validation to
      run.
    * `mcon` (`String`): MCON of the table to validate
    * `asset_id` (`String`): Full ID of the table to validate in the
      format: project:dataset.table, ignored if mcon is specified
    * `project` (`String`): Project (or database) containing the asset
      to validate. Ignored if mcon or asset_id are specified
    * `dataset` (`String`): Dataset (or schema) containing the asset
      to validate. Ignored if mcon or asset_id are specified
    * `asset_name` (`String`): Name of the asset to validate, for
      example table name. Ignored if mcon or asset_id are specified
    * `asset_type` (`DataAssetTypeEnum`): Asset type to validate, it
      could be table, external, snowflake_stream, etc., ignored if
      mcon is specified
    """

    validate_airflow_asset_access = sgqlc.types.Field(
        "ValidateDataAssetAccessResponse",
        graphql_name="validateAirflowAssetAccess",
        args=sgqlc.types.ArgDict(
            (
                (
                    "validation_names",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="validationNames", default=None
                    ),
                ),
                (
                    "dag_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="dagId", default=None
                    ),
                ),
                (
                    "etl_container_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="etlContainerUuid", default=None
                    ),
                ),
            )
        ),
    )
    """Arguments:

    * `validation_names` (`[String]`): Names of the Airflow asset
      validations to run.
    * `dag_id` (`String!`): The Airflow DAG id
    * `etl_container_uuid` (`UUID!`): The ETL Container UUID of the
      Airflow environment
    """

    test_existing_connection_v2 = sgqlc.types.Field(
        "TestCredentialsV2Response",
        graphql_name="testExistingConnectionV2",
        args=sgqlc.types.ArgDict(
            (
                (
                    "validation_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="validationName", default=None
                    ),
                ),
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
            )
        ),
    )
    """Execute a validation test on an integration

    Arguments:

    * `validation_name` (`String!`): Name of the validation that
      should be run.
    * `connection_id` (`UUID!`): An existing connection's UUID
    """

    test_storage_access = sgqlc.types.Field(
        "TestCredentialsV2Response",
        graphql_name="testStorageAccess",
        args=sgqlc.types.ArgDict(
            (("dc_id", sgqlc.types.Arg(UUID, graphql_name="dcId", default=None)),)
        ),
    )
    """Validates storage access for the account

    Arguments:

    * `dc_id` (`UUID`): DC UUID. To disambiguate accounts with
      multiple collectors.
    """

    test_data_store_reachability = sgqlc.types.Field(
        "TestCredentialsV2Response",
        graphql_name="testDataStoreReachability",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
            )
        ),
    )
    """Validates that Data Store is accessible for the account

    Arguments:

    * `agent_id` (`UUID!`): Identifies which storage to run the test
      against.
    """

    test_agent_reachability = sgqlc.types.Field(
        "TestCredentialsV2Response",
        graphql_name="testAgentReachability",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "validation_name",
                    sgqlc.types.Arg(String, graphql_name="validationName", default=None),
                ),
            )
        ),
    )
    """Validates that Agent is accessible for the account

    Arguments:

    * `agent_id` (`UUID!`): Identifies which agent to run the test
      against.
    * `validation_name` (`String`): Name of the validation that should
      be run.
    """

    list_projects = sgqlc.types.Field(
        ListProjectsResponse,
        graphql_name="listProjects",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
                ("page_token", sgqlc.types.Arg(String, graphql_name="pageToken", default=None)),
            )
        ),
    )
    """Lists projects for a given connection

    Arguments:

    * `connection_id` (`UUID!`): A connection ID
    * `page_size` (`Int`): The size of the page being requested.
    * `page_token` (`String`): The token for the page being requested.
    """

    list_datasets = sgqlc.types.Field(
        ListDatasetsResponse,
        graphql_name="listDatasets",
        args=sgqlc.types.ArgDict(
            (
                (
                    "connection_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="connectionId", default=None
                    ),
                ),
                (
                    "project_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="projectId", default=None
                    ),
                ),
                ("page_size", sgqlc.types.Arg(Int, graphql_name="pageSize", default=None)),
                ("page_token", sgqlc.types.Arg(String, graphql_name="pageToken", default=None)),
            )
        ),
    )
    """Lists datasets for a given connection

    Arguments:

    * `connection_id` (`UUID!`): A connection ID
    * `project_id` (`String!`): The ID of the project whose datasets
      are being queried
    * `page_size` (`Int`): The size of the page being requested.
    * `page_token` (`String`): The token for the page being requested.
    """

    get_data_export_url = sgqlc.types.Field(
        DataExportURL,
        graphql_name="getDataExportUrl",
        args=sgqlc.types.ArgDict(
            (
                (
                    "data_export_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DataExportNames),
                        graphql_name="dataExportName",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Get URL to download a specific Data Export file

    Arguments:

    * `data_export_name` (`DataExportNames!`): Name of Data Export to
      fetch
    """

    get_generate_report_status = sgqlc.types.Field(
        "ReportStatus",
        graphql_name="getGenerateReportStatus",
        args=sgqlc.types.ArgDict(
            (
                (
                    "report_job_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="reportJobId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get status of a generated report

    Arguments:

    * `report_job_id` (`UUID!`): Report Job ID
    """

    evaluate_asset_selection = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AssetSelectionResult)),
        graphql_name="evaluateAssetSelection",
        args=sgqlc.types.ArgDict(
            (
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                (
                    "asset_selection",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AssetSelectionInput),
                        graphql_name="assetSelection",
                        default=None,
                    ),
                ),
                (
                    "asset_selection_level",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AssetSelectionLevel),
                        graphql_name="assetSelectionLevel",
                        default=None,
                    ),
                ),
                (
                    "include_unselected",
                    sgqlc.types.Arg(Boolean, graphql_name="includeUnselected", default=None),
                ),
                (
                    "filter_by_database_name",
                    sgqlc.types.Arg(String, graphql_name="filterByDatabaseName", default=None),
                ),
                (
                    "filter_by_schema_name",
                    sgqlc.types.Arg(String, graphql_name="filterBySchemaName", default=None),
                ),
                (
                    "domain_restrictions",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="domainRestrictions",
                        default=None,
                    ),
                ),
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "rank_by_database_schema",
                    sgqlc.types.Arg(String, graphql_name="rankByDatabaseSchema", default=None),
                ),
                (
                    "search_full_table_id",
                    sgqlc.types.Arg(String, graphql_name="searchFullTableId", default=None),
                ),
                (
                    "is_monitored",
                    sgqlc.types.Arg(Boolean, graphql_name="isMonitored", default=None),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=100)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=0)),
            )
        ),
    )
    """(experimental) Evaluates an asset selection query and returns a
    list of asset selection results.

    Arguments:

    * `warehouse_uuid` (`UUID!`)None
    * `asset_selection` (`AssetSelectionInput!`)None
    * `asset_selection_level` (`AssetSelectionLevel!`)None
    * `include_unselected` (`Boolean`)None
    * `filter_by_database_name` (`String`)None
    * `filter_by_schema_name` (`String`)None
    * `domain_restrictions` (`[UUID!]`)None
    * `search` (`String`)None
    * `rank_by_database_schema` (`String`)None
    * `search_full_table_id` (`String`)None
    * `is_monitored` (`Boolean`): Filter by monitored status if
      provided
    * `limit` (`Int`)None (default: `100`)
    * `offset` (`Int`)None (default: `0`)
    """

    get_account_audit_logs = sgqlc.types.Field(
        GetAccountAuditLogsResponse,
        graphql_name="getAccountAuditLogs",
        args=sgqlc.types.ArgDict(
            (
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "include_api_queries",
                    sgqlc.types.Arg(Boolean, graphql_name="includeApiQueries", default=False),
                ),
                (
                    "api_call_references",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(ApiCallReference),
                        graphql_name="apiCallReferences",
                        default=None,
                    ),
                ),
                ("user_email", sgqlc.types.Arg(String, graphql_name="userEmail", default=None)),
            )
        ),
    )
    """Get audit logs for an account.

    Arguments:

    * `first` (`Int`): When paging forward: the number of items to
      return (page size)
    * `after` (`String`): When paging forward: the cursor of the last
      item on the previous page of results
    * `last` (`Int`): When paging backward: the number of items to
      return (page size)
    * `before` (`String`): When paging backward: the cursor of the
      first item on the next page of results
    * `start_time` (`DateTime!`): Start time of the time range to
      query
    * `end_time` (`DateTime`): End time of the time range to query.
      Defaults to current time
    * `include_api_queries` (`Boolean`): If set to true, GraphQL API
      calls that are queries (not mutations) will be included in the
      response. By default, queries are not included. (default:
      `false`)
    * `api_call_references` (`[ApiCallReference]`): References (For
      instance UUIDs) that were passed as input to GraphQL API calls
    * `user_email` (`String`): Filter activity of a specific user
    """

    get_monitor_audit_logs = sgqlc.types.Field(
        AuditLogEntryConnection,
        graphql_name="getMonitorAuditLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="monitorUuid", default=None
                    ),
                ),
                ("change_field", sgqlc.types.Arg(String, graphql_name="changeField", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "timestamp__lt",
                    sgqlc.types.Arg(DateTime, graphql_name="timestamp_Lt", default=None),
                ),
            )
        ),
    )
    """Get audit logs for specified monitor

    Arguments:

    * `monitor_uuid` (`UUID!`): UUID of monitor
    * `change_field` (`String`): Filter logs by specific field that
      was changed
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `timestamp__lt` (`DateTime`)None
    """

    get_monitored_rules_audit_logs = sgqlc.types.Field(
        AuditLogEntryConnection,
        graphql_name="getMonitoredRulesAuditLogs",
        args=sgqlc.types.ArgDict(
            (
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "timestamp__lt",
                    sgqlc.types.Arg(DateTime, graphql_name="timestamp_Lt", default=None),
                ),
            )
        ),
    )
    """Get usage audit logs

    Arguments:

    * `start_time` (`DateTime`): Start time to fetch audit logs.
      Defaults to current time - 30 days
    * `end_time` (`DateTime`): End time for fetching audit logs.
      Defaults to current time.
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `timestamp__lt` (`DateTime`)None
    """

    get_alerts = sgqlc.types.Field(
        AlertConnection,
        graphql_name="getAlerts",
        args=sgqlc.types.ArgDict(
            (
                (
                    "updated_time",
                    sgqlc.types.Arg(DateTimeRangeInput, graphql_name="updatedTime", default=None),
                ),
                (
                    "created_time",
                    sgqlc.types.Arg(DateTimeRangeInput, graphql_name="createdTime", default=None),
                ),
                (
                    "ids",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(sgqlc.types.non_null(UUID)),
                        graphql_name="ids",
                        default=None,
                    ),
                ),
                ("filter", sgqlc.types.Arg(AlertsFilterInput, graphql_name="filter", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """(experimental) Get alerts (i.e. a collection of related events) in
    my account within a 2 month time range. Excludes alerts that have
    been merged into another.

    Arguments:

    * `updated_time` (`DateTimeRangeInput`): Supply a time range
      within 2 months. Either this or `createdTime` or `ids` must be
      provided.
    * `created_time` (`DateTimeRangeInput`): Supply a time range
      within 2 months. Either this or `updatedTime` or `ids` must be
      provided.
    * `ids` (`[UUID!]`): Either this or `updated_time` or
      `createdTime` must be provided.
    * `filter` (`AlertsFilterInput`): Filter alerts.
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `order_by` (`String`): Order results by `createdTime` or
      `updatedTime`
    """

    get_alert = sgqlc.types.Field(
        "GenericAlert",
        graphql_name="getAlert",
        args=sgqlc.types.ArgDict(
            (("id", sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="id", default=None)),)
        ),
    )
    """(experimental) Returns an alert or a merged alert (which only
    contains data to inform which alert it was merged into).

    Arguments:

    * `id` (`UUID!`)None
    """

    get_alert_description = sgqlc.types.Field(
        AlertDescriptionOutput,
        graphql_name="getAlertDescription",
        args=sgqlc.types.ArgDict(
            (("id", sgqlc.types.Arg(sgqlc.types.non_null(UUID), graphql_name="id", default=None)),)
        ),
    )
    """(experimental) Get a textual representation of an alert's
    description

    Arguments:

    * `id` (`UUID!`): UUID of the alert
    """

    get_alerts_filters = sgqlc.types.Field(
        sgqlc.types.list_of(AlertsFilter), graphql_name="getAlertsFilters"
    )
    """(experimental) Filters that can be applied when requesting for a
    list of alerts
    """

    get_alerts_filters_data = sgqlc.types.Field(
        sgqlc.types.list_of(AlertsFilterData),
        graphql_name="getAlertsFiltersData",
        args=sgqlc.types.ArgDict(
            (
                (
                    "request",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(AlertsFilterDataRequestType)),
                        graphql_name="request",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """(experimental) Filters that can be applied when requesting for a
    list of alerts

    Arguments:

    * `request` (`[AlertsFilterDataRequestType]!`)None
    """

    get_alerts_count_by_date = sgqlc.types.Field(
        AlertsCountByDateConnection,
        graphql_name="getAlertsCountByDate",
        args=sgqlc.types.ArgDict(
            (
                (
                    "updated_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTimeRangeInput),
                        graphql_name="updatedTime",
                        default=None,
                    ),
                ),
                ("filter", sgqlc.types.Arg(AlertsFilterInput, graphql_name="filter", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """(experimental) Get alert count by the updated_time date.

    Arguments:

    * `updated_time` (`DateTimeRangeInput!`): Supply a time range
      within 2 months.
    * `filter` (`AlertsFilterInput`): Filter alerts.
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_alert_access_request = sgqlc.types.Field(
        AlertAccessRequest,
        graphql_name="getAlertAccessRequest",
        args=sgqlc.types.ArgDict(
            (
                (
                    "alert_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="alertId", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) DEPRECATED. Get the status of an alert access
    request for the current user

    Arguments:

    * `alert_id` (`UUID!`): UUID of the alert
    """

    get_collibra_ping = sgqlc.types.Field(
        CollibraPingResponse,
        graphql_name="getCollibraPing",
        args=sgqlc.types.ArgDict(
            (
                ("server_url", sgqlc.types.Arg(String, graphql_name="serverUrl", default=None)),
                ("username", sgqlc.types.Arg(String, graphql_name="username", default=None)),
                ("password", sgqlc.types.Arg(String, graphql_name="password", default=None)),
            )
        ),
    )
    """(experimental) Collibra ping

    Arguments:

    * `server_url` (`String`): Optional server url. Otherwise taken
      from existing integration
    * `username` (`String`): Optional username. Otherwise taken from
      existing integration
    * `password` (`String`): Optional password. Otherwise taken from
      existing integration
    """

    get_collibra_monitor_note = sgqlc.types.Field(
        CollibraMonitorNoteResponse,
        graphql_name="getCollibraMonitorNote",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Collibra monitor note. Has extra debug information
    about table relationships if they could not be found

    Arguments:

    * `monitor_uuid` (`String!`): Monitor uuid
    """

    get_collibra_monitor_table_search_names = sgqlc.types.Field(
        sgqlc.types.list_of(String),
        graphql_name="getCollibraMonitorTableSearchNames",
        args=sgqlc.types.ArgDict(
            (
                (
                    "monitor_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="monitorUuid", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get table search names for a monitor in Collibra
    format

    Arguments:

    * `monitor_uuid` (`String!`): Monitor uuid
    """

    get_collibra_domains_for_table_search_name = sgqlc.types.Field(
        sgqlc.types.list_of(CollibraDomainSearchResponse),
        graphql_name="getCollibraDomainsForTableSearchName",
        args=sgqlc.types.ArgDict(
            (
                (
                    "table_search_name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="tableSearchName", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get Collibra domain information for a table search
    name

    Arguments:

    * `table_search_name` (`String!`): Table search name in Collibra
      format (e.g., '>project>dataset>table')
    """

    get_alation_table_flags = sgqlc.types.Field(
        sgqlc.types.list_of(GetAlationTableFlags),
        graphql_name="getAlationTableFlags",
        args=sgqlc.types.ArgDict(
            (
                (
                    "mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="mcon", default=None
                    ),
                ),
            )
        ),
    )
    """Gets warning and deprecation flags set in Alation for this table.

    Arguments:

    * `mcon` (`String!`): The MCON of the table
    """

    get_airflow_task_results = sgqlc.types.Field(
        AirflowTaskRunConnection,
        graphql_name="getAirflowTaskResults",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
                ("from_date", sgqlc.types.Arg(DateTime, graphql_name="fromDate", default=None)),
                ("to_date", sgqlc.types.Arg(DateTime, graphql_name="toDate", default=None)),
                ("success", sgqlc.types.Arg(Boolean, graphql_name="success", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
                ("dag_id", sgqlc.types.Arg(String, graphql_name="dagId", default=None)),
                ("task_id", sgqlc.types.Arg(String, graphql_name="taskId", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("job_mcon", sgqlc.types.Arg(String, graphql_name="jobMcon", default=None)),
                ("task_mcon", sgqlc.types.Arg(String, graphql_name="taskMcon", default=None)),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
                ("run_id", sgqlc.types.Arg(String, graphql_name="runId", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get Airflow Task runs

    Arguments:

    * `resource_name` (`String`): Filter by ETL container
    * `from_date` (`DateTime`): Filter date range start, optional only
      if runId is specified
    * `to_date` (`DateTime`): Filter date range end
    * `success` (`Boolean`): Filter by success or failure
    * `state` (`String`): Filter by state
    * `dag_id` (`String`): Deprecated, use jobMcon. Filter by DAG ID
    * `task_id` (`String`): Deprecated, use taskMcon. Filter by Task
      ID
    * `mcons` (`[String]`): Deprecated, use tableMcons. Filter by list
      of table MCONs
    * `job_mcon` (`String`): Filter by Job MCON
    * `task_mcon` (`String`): Filter by Task MCON
    * `table_mcons` (`[String]`): Filter by list of table MCONs
    * `run_id` (`String`): Filter by Run ID
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_airflow_task_stats = sgqlc.types.Field(
        AirflowTaskRunStatsConnection,
        graphql_name="getAirflowTaskStats",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
                (
                    "from_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="fromDate", default=None
                    ),
                ),
                ("to_date", sgqlc.types.Arg(DateTime, graphql_name="toDate", default=None)),
                ("success", sgqlc.types.Arg(Boolean, graphql_name="success", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
                (
                    "mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="mcons", default=None
                    ),
                ),
                ("dag_id", sgqlc.types.Arg(String, graphql_name="dagId", default=None)),
                (
                    "table_mcons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="tableMcons", default=None
                    ),
                ),
                ("job_mcon", sgqlc.types.Arg(String, graphql_name="jobMcon", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get Airflow Task statistics

    Arguments:

    * `resource_name` (`String`): Filter by ETL container
    * `from_date` (`DateTime!`): Filter date range start
    * `to_date` (`DateTime`): Filter date range end
    * `success` (`Boolean`): Filter by success or failure
    * `state` (`String`): Filter by state
    * `mcons` (`[String]`): Deprecated, use tableMcons. Filter by list
      of table MCONs
    * `dag_id` (`String`): Deprecated, use jobMcon. Filter by DAG ID
    * `table_mcons` (`[String]`): Filter by list of table MCONs
    * `job_mcon` (`String`): Filter by Job MCON
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_airflow_tasks_for_source_and_destination_tables = sgqlc.types.Field(
        AirflowTaskRunStatsConnection,
        graphql_name="getAirflowTasksForSourceAndDestinationTables",
        args=sgqlc.types.ArgDict(
            (
                (
                    "resource_name",
                    sgqlc.types.Arg(String, graphql_name="resourceName", default=None),
                ),
                (
                    "source_table_mcon",
                    sgqlc.types.Arg(String, graphql_name="sourceTableMcon", default=None),
                ),
                (
                    "destination_table_mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String),
                        graphql_name="destinationTableMcon",
                        default=None,
                    ),
                ),
                (
                    "from_date",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="fromDate", default=None
                    ),
                ),
                ("to_date", sgqlc.types.Arg(DateTime, graphql_name="toDate", default=None)),
                ("success", sgqlc.types.Arg(Boolean, graphql_name="success", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
                ("dag_id", sgqlc.types.Arg(String, graphql_name="dagId", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Get Airflow Tasks for source and destination tables

    Arguments:

    * `resource_name` (`String`): Filter by ETL container
    * `source_table_mcon` (`String`): The table mcon from where the
      jobs are reading data
    * `destination_table_mcon` (`String!`): The table mcon to where
      the jobs are modifying the data
    * `from_date` (`DateTime!`): Filter date range start
    * `to_date` (`DateTime`): Filter date range end
    * `success` (`Boolean`): Filter by success or failure
    * `state` (`String`): Filter by state
    * `dag_id` (`String`): Deprecated, use jobMcon. Filter by DAG ID
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    get_airflow_dag_runs = sgqlc.types.Field(
        sgqlc.types.list_of(AirflowDagRunInfo),
        graphql_name="getAirflowDagRuns",
        args=sgqlc.types.ArgDict(
            (
                (
                    "job_mcon",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="jobMcon", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=20)),
                ("from_date", sgqlc.types.Arg(DateTime, graphql_name="fromDate", default=None)),
                ("to_date", sgqlc.types.Arg(DateTime, graphql_name="toDate", default=None)),
            )
        ),
    )
    """List of runs for a given DAG. Optionally filter by start date and
    end date

    Arguments:

    * `job_mcon` (`String!`): Job MCON to filter by
    * `limit` (`Int`): Number of runs to return (default: `20`)
    * `from_date` (`DateTime`): Filter runs with start_date >=
      from_date
    * `to_date` (`DateTime`): Filter runs with start_date <= to_date
    """

    get_airflow_capabilities = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowCapabilitiesResponse),
        graphql_name="getAirflowCapabilities",
        args=sgqlc.types.ArgDict(
            (
                (
                    "etl_container_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="etlContainerUuid", default=None),
                ),
            )
        ),
    )
    """Airflow Capabilities

    Arguments:

    * `etl_container_uuid` (`UUID`): UUID of ETL Container
    """

    get_ai_agent_config = sgqlc.types.Field(
        AiAgent,
        graphql_name="getAiAgentConfig",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_type",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(AiAgentType), graphql_name="agentType", default=None
                    ),
                ),
            )
        ),
    )
    """(experimental) Get AI agent configuration for the account

    Arguments:

    * `agent_type` (`AiAgentType!`): Type of AI agent to retrieve
      configuration for
    """

    fix_sql_query = sgqlc.types.Field(
        AIMessageOutput,
        graphql_name="fixSqlQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "sql_query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="sqlQuery", default=None
                    ),
                ),
                (
                    "error_message",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="errorMessage", default=None
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                ("request_uuid", sgqlc.types.Arg(UUID, graphql_name="requestUuid", default=None)),
            )
        ),
    )
    """Given a SQL query it uses AI to fix it

    Arguments:

    * `sql_query` (`String!`): SQL query to fix
    * `error_message` (`String!`): Error message
    * `warehouse_uuid` (`UUID!`): The identifier of warehouse that is
      being queried
    * `request_uuid` (`UUID`): The identifier of the request if we
      want to stream the results
    """

    create_sql_query = sgqlc.types.Field(
        AIMessageOutput,
        graphql_name="createSqlQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "messages",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(sgqlc.types.list_of(AIMessageInput)),
                        graphql_name="messages",
                        default=None,
                    ),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="warehouseUuid", default=None
                    ),
                ),
                ("request_uuid", sgqlc.types.Arg(UUID, graphql_name="requestUuid", default=None)),
            )
        ),
    )
    """Convert natural language into a SQL query

    Arguments:

    * `messages` (`[AIMessageInput]!`): Messages between the user and
      the AI
    * `warehouse_uuid` (`UUID!`): The identifier of the data warehouse
      that is being queried
    * `request_uuid` (`UUID`): The identifier of the request if we
      want to stream the results
    """

    get_agent_operation_logs = sgqlc.types.Field(
        sgqlc.types.list_of(AgentLogEntry),
        graphql_name="getAgentOperationLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                (
                    "connection_type",
                    sgqlc.types.Arg(String, graphql_name="connectionType", default=None),
                ),
            )
        ),
    )
    """Get Agent operations log entries for a given time period,
    optionally matching a connection type

    Arguments:

    * `agent_id` (`UUID!`): Agent ID
    * `start_time` (`DateTime`): Optional start time, defaults to 10
      minutes ago
    * `end_time` (`DateTime`): Optional end time, defaults to now
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 1000
    * `connection_type` (`String`): Optional connection type, for
      example "snowflake", "redshift", etc.
    """

    get_gcp_agent_logs = sgqlc.types.Field(
        sgqlc.types.list_of(AgentLogEntry),
        graphql_name="getGcpAgentLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("logs_filter", sgqlc.types.Arg(String, graphql_name="logsFilter", default=None)),
            )
        ),
    )
    """Get GCP Agent log entries for a given time period, optionally
    matching a filter

    Arguments:

    * `agent_id` (`UUID!`): GCP Agent ID
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 1000
    * `logs_filter` (`String`): Optional filter, for example:
      SEARCH("text") or timestamp >= "2023-01-01T00:00:00Z"
    """

    get_azure_agent_logs = sgqlc.types.Field(
        sgqlc.types.list_of(AgentLogEntry),
        graphql_name="getAzureAgentLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)),
            )
        ),
    )
    """Get Azure Agent log entries for a given time period, optionally
    matching a query

    Arguments:

    * `agent_id` (`UUID!`): Azure Agent ID
    * `start_time` (`DateTime`): Optional start time, defaults to 10
      minutes ago
    * `end_time` (`DateTime`): Optional end time, defaults to now
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 1000
    * `query` (`String`): Optional query, for example: where message
      like "pattern"
    """

    get_azure_agent_tasks_summary = sgqlc.types.Field(
        AzureAgentTasksSummary,
        graphql_name="getAzureAgentTasksSummary",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "created_time_from",
                    sgqlc.types.Arg(DateTime, graphql_name="createdTimeFrom", default=None),
                ),
                (
                    "created_time_to",
                    sgqlc.types.Arg(DateTime, graphql_name="createdTimeTo", default=None),
                ),
            )
        ),
    )
    """Get Durable Functions tasks summary for an Azure Agent.

    Arguments:

    * `agent_id` (`UUID!`): Azure Agent ID
    * `created_time_from` (`DateTime`): Optional start time, defaults
      to 24 hours ago
    * `created_time_to` (`DateTime`): Optional end time, defaults to
      now
    """

    get_snowflake_agent_logs = sgqlc.types.Field(
        sgqlc.types.list_of(AgentLogEntry),
        graphql_name="getSnowflakeAgentLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
            )
        ),
    )
    """(general availability) Get Snowflake Agent log entries

    Arguments:

    * `agent_id` (`UUID!`): Snowflake Agent ID
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 1000
    """

    get_aws_agent_logs = sgqlc.types.Field(
        sgqlc.types.list_of(AgentLogEntry),
        graphql_name="getAwsAgentLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("pattern", sgqlc.types.Arg(String, graphql_name="pattern", default=None)),
            )
        ),
    )
    """Get AWS Agent log entries for a given time period, optionally
    matching a filter

    Arguments:

    * `agent_id` (`UUID!`): AWS Agent ID
    * `start_time` (`DateTime`): Optional start time, defaults to 10
      minutes ago
    * `end_time` (`DateTime`): Optional end time, defaults to now
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 1000
    * `pattern` (`String`): Optional pattern, for example: %text%
    """

    start_aws_logs_query = sgqlc.types.Field(
        AwsAgentStartLogsQueryResult,
        graphql_name="startAwsLogsQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                (
                    "query",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="query", default=None
                    ),
                ),
            )
        ),
    )
    """Get the results of a query started using start_aws_logs_query.

    Arguments:

    * `agent_id` (`UUID!`): Agent ID
    * `start_time` (`DateTime`): Optional start time, defaults to 10
      minutes ago
    * `end_time` (`DateTime`): Optional end time, defaults to now
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 1000
    * `query` (`String!`): The CloudWatch query following the syntax
      defined at: https://docs.aws.amazon.com/AmazonCloudWatch/latest/
      logs/CWL_QuerySyntax.html. For example: 'fields @timestamp,
      @message | filter @message like "error"'
    """

    stop_aws_logs_query = sgqlc.types.Field(
        AwsAgentLogsStopQueryResult,
        graphql_name="stopAwsLogsQuery",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "query_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryId", default=None
                    ),
                ),
            )
        ),
    )
    """Stops a query started using start_aws_logs_query.

    Arguments:

    * `agent_id` (`UUID!`): Agent ID
    * `query_id` (`String!`): The query_id as returned by
      start_aws_query
    """

    get_aws_logs_query_results = sgqlc.types.Field(
        AwsAgentLogsQueryResult,
        graphql_name="getAwsLogsQueryResults",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                (
                    "query_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="queryId", default=None
                    ),
                ),
            )
        ),
    )
    """Get the results of a query started using start_aws_logs_query.

    Arguments:

    * `agent_id` (`UUID!`): Agent ID
    * `query_id` (`String!`): The query_id as returned by
      start_aws_query
    """

    get_aws_agent_upgrade_logs = sgqlc.types.Field(
        sgqlc.types.list_of(AwsAgentUpgradeLogEntry),
        graphql_name="getAwsAgentUpgradeLogs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
                ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
            )
        ),
    )
    """Get AWS Agent upgrade log entries from a given start time.

    Arguments:

    * `agent_id` (`UUID!`): AWS Agent ID.
    * `limit` (`Int`): Maximum number of entries to return, defaults
      to 100
    * `start_time` (`DateTime`): Optional start time, defaults to 12
      hours ago
    """

    get_aws_agent_infra_details = sgqlc.types.Field(
        AwsAgentInfraDetailsResult,
        graphql_name="getAwsAgentInfraDetails",
        args=sgqlc.types.ArgDict(
            (
                (
                    "agent_id",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(UUID), graphql_name="agentId", default=None
                    ),
                ),
            )
        ),
    )
    """Get infrastructure information from an AWS Agent like
    CloudFormation template and parameters.

    Arguments:

    * `agent_id` (`UUID!`): Agent ID
    """

    get_account_secret = sgqlc.types.Field(
        AccountSecretOutput,
        graphql_name="getAccountSecret",
        args=sgqlc.types.ArgDict(
            (
                (
                    "name",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(String), graphql_name="name", default=None
                    ),
                ),
                ("reveal", sgqlc.types.Arg(Boolean, graphql_name="reveal", default=None)),
            )
        ),
    )
    """Get an account secret

    Arguments:

    * `name` (`String!`): If the secret name
    * `reveal` (`Boolean`): If the secret value must be returned
    """

    get_account_secrets = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AccountSecretOutput))),
        graphql_name="getAccountSecrets",
    )


class QueryDataObject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "query_id",
        "group_id",
        "user_name",
        "timestamp",
        "query",
        "source_display_name",
        "destination_display_name",
        "error_code",
        "error_msg",
    )
    query_id = sgqlc.types.Field(String, graphql_name="queryId")

    group_id = sgqlc.types.Field(String, graphql_name="groupId")

    user_name = sgqlc.types.Field(String, graphql_name="userName")

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")

    query = sgqlc.types.Field(String, graphql_name="query")

    source_display_name = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="sourceDisplayName"
    )

    destination_display_name = sgqlc.types.Field(String, graphql_name="destinationDisplayName")

    error_code = sgqlc.types.Field(String, graphql_name="errorCode")

    error_msg = sgqlc.types.Field(String, graphql_name="errorMsg")


class QueryDimensions(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("users", "categories")
    users = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="users")
    """A distinct list of users for a list of queries"""

    categories = sgqlc.types.Field(sgqlc.types.list_of(QueryCategory), graphql_name="categories")
    """A distinct list of query categories for a list of queries"""


class QueryGroupSummaryType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "query_group_field",
        "query_group_value",
        "query_snippet",
        "user_email",
        "query_count",
        "avg_runtime",
        "max_runtime",
        "sum_runtime",
        "avg_metric",
        "max_metric",
        "sum_metric",
        "warehouse_uuid",
        "destination",
        "destination_mcon",
        "displayable_field_values",
    )
    query_group_field = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="queryGroupField"
    )

    query_group_value = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="queryGroupValue"
    )

    query_snippet = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="querySnippet")

    user_email = sgqlc.types.Field(String, graphql_name="userEmail")
    """DEPRECATED (use displayableFieldValues)"""

    query_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="queryCount")

    avg_runtime = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="avgRuntime")

    max_runtime = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="maxRuntime")

    sum_runtime = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="sumRuntime")

    avg_metric = sgqlc.types.Field(Float, graphql_name="avgMetric")

    max_metric = sgqlc.types.Field(Float, graphql_name="maxMetric")

    sum_metric = sgqlc.types.Field(Float, graphql_name="sumMetric")

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="warehouseUuid")

    destination = sgqlc.types.Field(String, graphql_name="destination")

    destination_mcon = sgqlc.types.Field(String, graphql_name="destinationMcon")

    displayable_field_values = sgqlc.types.Field(
        sgqlc.types.list_of(DisplayableFieldValueType), graphql_name="displayableFieldValues"
    )


class QueryListObject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "query_id",
        "user_name",
        "timestamp",
        "query_length",
        "query_hash",
        "group_hash",
        "sub_category",
        "query_snippet",
        "runtime",
        "rows_produced",
        "rows_updated",
        "rows_inserted",
        "rows_produced_float",
        "rows_updated_float",
        "rows_inserted_float",
        "status",
    )
    query_id = sgqlc.types.Field(String, graphql_name="queryId")

    user_name = sgqlc.types.Field(String, graphql_name="userName")

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")

    query_length = sgqlc.types.Field(Int, graphql_name="queryLength")

    query_hash = sgqlc.types.Field(String, graphql_name="queryHash")

    group_hash = sgqlc.types.Field(String, graphql_name="groupHash")

    sub_category = sgqlc.types.Field(String, graphql_name="subCategory")

    query_snippet = sgqlc.types.Field(String, graphql_name="querySnippet")

    runtime = sgqlc.types.Field(Int, graphql_name="runtime")

    rows_produced = sgqlc.types.Field(Int, graphql_name="rowsProduced")

    rows_updated = sgqlc.types.Field(Int, graphql_name="rowsUpdated")

    rows_inserted = sgqlc.types.Field(Int, graphql_name="rowsInserted")

    rows_produced_float = sgqlc.types.Field(Float, graphql_name="rowsProducedFloat")

    rows_updated_float = sgqlc.types.Field(Float, graphql_name="rowsUpdatedFloat")

    rows_inserted_float = sgqlc.types.Field(Float, graphql_name="rowsInsertedFloat")

    status = sgqlc.types.Field(String, graphql_name="status")


class QueryListResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("queries", "queries_by_type", "offset", "total", "timeline")
    queries = sgqlc.types.Field(sgqlc.types.list_of(QueryListObject), graphql_name="queries")

    queries_by_type = sgqlc.types.Field(
        sgqlc.types.list_of("QueryMapObject"), graphql_name="queriesByType"
    )

    offset = sgqlc.types.Field(Int, graphql_name="offset")

    total = sgqlc.types.Field(Int, graphql_name="total")

    timeline = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="timeline")


class QueryLogHash(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "query",
        "query_hash",
        "user_email",
        "day",
        "count",
        "category",
        "average_elapsed_time",
    )
    query = sgqlc.types.Field(String, graphql_name="query")
    """A substring of the query containing the first n characters defined
    by the query_characters parameter in the query
    """

    query_hash = sgqlc.types.Field(String, graphql_name="queryHash")
    """Hash of the query"""

    user_email = sgqlc.types.Field(String, graphql_name="userEmail")
    """User email"""

    day = sgqlc.types.Field(DateTime, graphql_name="day")
    """Day of the query log hash"""

    count = sgqlc.types.Field(Int, graphql_name="count")
    """Count of the number of queries with the same hash in the day"""

    category = sgqlc.types.Field(String, graphql_name="category")
    """Category of the query log hash"""

    average_elapsed_time = sgqlc.types.Field(Int, graphql_name="averageElapsedTime")
    """Average elapsed time of the query log hash in milliseconds"""


class QueryLogHashes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("full_table_id", "offset", "query_hashes")
    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    offset = sgqlc.types.Field(Int, graphql_name="offset")

    query_hashes = sgqlc.types.Field(sgqlc.types.list_of(QueryLogHash), graphql_name="queryHashes")


class QueryLogMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metadata", "timestamp")
    metadata = sgqlc.types.Field(String, graphql_name="metadata")

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")


class QueryLogResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query_data", "queries", "offset")
    query_data = sgqlc.types.Field(QueryDataObject, graphql_name="queryData")

    queries = sgqlc.types.Field(sgqlc.types.list_of(QueryLogMetadata), graphql_name="queries")

    offset = sgqlc.types.Field(Int, graphql_name="offset")


class QueryLogResultType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "timestamp",
        "warehouse_uuid",
        "query_id",
        "query_snippet",
        "query",
        "query_group",
        "query_length",
        "user",
        "status",
        "destination",
        "runtime",
        "displayable_field_values",
        "destination_mcon",
        "job_info",
    )
    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="warehouseUuid")

    query_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="queryId")

    query_snippet = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="querySnippet")

    query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="query")

    query_group = sgqlc.types.Field(String, graphql_name="queryGroup")

    query_length = sgqlc.types.Field(Int, graphql_name="queryLength")

    user = sgqlc.types.Field(String, graphql_name="user")
    """DEPRECATED, use displayableFieldValues"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """DEPRECATED, use displayableFieldValues"""

    destination = sgqlc.types.Field(String, graphql_name="destination")
    """DEPRECATED, use displayableFieldValues"""

    runtime = sgqlc.types.Field(Int, graphql_name="runtime")

    displayable_field_values = sgqlc.types.Field(
        sgqlc.types.list_of(DisplayableFieldValueType), graphql_name="displayableFieldValues"
    )

    destination_mcon = sgqlc.types.Field(String, graphql_name="destinationMcon")

    job_info = sgqlc.types.Field(JobInfo, graphql_name="jobInfo")


class QueryLogTimeline(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total", "results")
    total = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="total")
    """Total count of timeline items"""

    results = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="results"
    )
    """Timeline items (comma-separated fields
    "timestamp,query_id,query_length,query_group,query_type")
    """


class QueryLogsFacetResponseType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("field_name", "facet_results")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field name"""

    facet_results = sgqlc.types.Field(
        sgqlc.types.list_of(FacetResultType), graphql_name="facetResults"
    )
    """Facet results"""


class QueryLogsResponseType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total", "results")
    total = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="total")

    results = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(QueryLogResultType)), graphql_name="results"
    )


class QueryMapObject(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("queries", "query_length")
    queries = sgqlc.types.Field(sgqlc.types.list_of(QueryListObject), graphql_name="queries")

    query_length = sgqlc.types.Field(Int, graphql_name="queryLength")


class QueryRca(sgqlc.types.Type):
    """Query RCA result"""

    __schema__ = schema
    __field_names__ = ("table_mcon", "group_id", "timestamp", "type", "rca_data", "event_uuid")
    table_mcon = sgqlc.types.Field(String, graphql_name="tableMcon")
    """MCON of affected table"""

    group_id = sgqlc.types.Field(String, graphql_name="groupId")
    """Identifier for a grouping of like/same queries"""

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """Time RCA was executed"""

    type = sgqlc.types.Field(QueryRcaType, graphql_name="type")
    """Type of query RCA"""

    rca_data = sgqlc.types.Field(JSONString, graphql_name="rcaData")
    """Get full rca data"""

    event_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="eventUuid")
    """The uuid connected of the event the RCA is connected to"""


class QueryRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "dynamic_fields",
        "fields",
        "filters",
        "model",
        "query_timezone",
        "url",
        "view",
    )
    dynamic_fields = sgqlc.types.Field(String, graphql_name="dynamicFields")

    fields = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fields")

    filters = sgqlc.types.Field(String, graphql_name="filters")

    model = sgqlc.types.Field(String, graphql_name="model")

    query_timezone = sgqlc.types.Field(String, graphql_name="queryTimezone")

    url = sgqlc.types.Field(String, graphql_name="url")

    view = sgqlc.types.Field(String, graphql_name="view")


class QueryResponseField(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "sql_alias", "display_name", "extra")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    sql_alias = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlAlias")

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")

    extra = sgqlc.types.Field(sgqlc.types.non_null(GenericScalar), graphql_name="extra")


class QueryResponseFieldType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "sql_alias", "display_name", "extra")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The canonical name of this field"""

    sql_alias = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlAlias")
    """How to find this field in the column header of the query's
    response
    """

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Description of this field"""

    extra = sgqlc.types.Field(JSONString, graphql_name="extra")
    """Extra metadata for this field"""


class QueryResponseMetadataType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query_response_fields",)
    query_response_fields = sgqlc.types.Field(
        sgqlc.types.list_of(QueryResponseFieldType), graphql_name="queryResponseFields"
    )
    """Metadata about each field in response"""


class QueryRuntimePercentileTimeSeriesResponseType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_series_list", "time_bucket_size")
    time_series_list = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TimeSeries")), graphql_name="timeSeriesList"
    )

    time_bucket_size = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="timeBucketSize"
    )


class QuerySelection(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query_type", "indexed_field_filters")
    query_type = sgqlc.types.Field(QueryLogType, graphql_name="queryType")
    """Type of the monitored queries"""

    indexed_field_filters = sgqlc.types.Field(
        sgqlc.types.list_of(IndexedFieldFilterOutputType), graphql_name="indexedFieldFilters"
    )
    """Selection criteria of the monitored queries"""


class QueryTemplateOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "sql_query", "variables")
    id = sgqlc.types.Field(String, graphql_name="id")
    """The template ID"""

    sql_query = sgqlc.types.Field(String, graphql_name="sqlQuery")
    """The SQL query template"""

    variables = sgqlc.types.Field(
        sgqlc.types.list_of("QueryTemplateVariable"), graphql_name="variables"
    )
    """Variables for the query"""


class QueryTemplateVariable(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name",)
    name = sgqlc.types.Field(String, graphql_name="name")
    """Variable name"""


class QueryTemplateVariableValueOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value", "value_json")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Variable name"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Variable value"""

    value_json = sgqlc.types.Field(JSONString, graphql_name="valueJson")
    """Variable value (in JSON)"""


class QueryWithResults(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query", "rows")
    query = sgqlc.types.Field(String, graphql_name="query")
    """The query that was executed."""

    rows = sgqlc.types.Field(String, graphql_name="rows")
    """Result of the query that was run. Either number of rows or the
    serialized representation of the rows themselves.
    """


class RcaJob(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "uuid",
        "job_type",
        "event",
        "set_ts",
        "status",
        "execution_stats",
        "job_execution_uuid",
        "status_reason",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    job_type = sgqlc.types.Field(sgqlc.types.non_null(RcaJobsModelJobType), graphql_name="jobType")

    event = sgqlc.types.Field(sgqlc.types.non_null("Event"), graphql_name="event")

    set_ts = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="setTs")

    status = sgqlc.types.Field(RcaJobsModelStatus, graphql_name="status")
    """Status of the RCA cached for fast look-up"""

    execution_stats = sgqlc.types.Field(JSONString, graphql_name="executionStats")

    job_execution_uuid = sgqlc.types.Field(UUID, graphql_name="jobExecutionUuid")

    status_reason = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(EventRcaStatusModelType))),
        graphql_name="statusReason",
    )


class RcaPlotData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("label", "timestamp", "value")
    label = sgqlc.types.Field(String, graphql_name="label")
    """Plot point label"""

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """Plot point position on the time axis"""

    value = sgqlc.types.Field(Int, graphql_name="value")
    """Plot point value"""


class RcaResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("status", "job_type", "status_reasons", "rca_data", "rca_data_v2")
    status = sgqlc.types.Field(RcaStatus, graphql_name="status")

    job_type = sgqlc.types.Field(sgqlc.types.non_null(RcaJobsModelJobType), graphql_name="jobType")

    status_reasons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(EventRcaStatusModelReason)),
        graphql_name="statusReasons",
        args=sgqlc.types.ArgDict(
            (("event_uuid", sgqlc.types.Arg(UUID, graphql_name="eventUuid", default=None)),)
        ),
    )
    """Arguments:

    * `event_uuid` (`UUID`)None
    """

    rca_data = sgqlc.types.Field(FieldDistRcaResult, graphql_name="rcaData")

    rca_data_v2 = sgqlc.types.Field("RcaData", graphql_name="rcaDataV2")


class ReInviteUsers(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("invites", "existing_users")
    invites = sgqlc.types.Field(sgqlc.types.list_of("UserInvite"), graphql_name="invites")
    """List of users to resend invites"""

    existing_users = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="existingUsers")
    """List of email addresses of users who already exist and cannot be
    invited
    """


class RefreshEntitlements(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if the entitlements refresh was successful"""


class RegisterGithubAppInstallationRequest(sgqlc.types.Type):
    """Called from the FE as part of the post-installation callback in
    case the user requested approval from her Github admin, instead of
    approving directly. The "code" parameter is used to identify the
    Github user of the requester.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if the registration was successful"""


class RegisterGitlabApp(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("auth_url",)
    auth_url = sgqlc.types.Field(String, graphql_name="authUrl")
    """GitLab URL to request authorization code"""


class RelatedUserCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("user", "count")
    user = sgqlc.types.Field(String, graphql_name="user")

    count = sgqlc.types.Field(Int, graphql_name="count")


class RelinkOpsgenieIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("restored",)
    restored = sgqlc.types.Field(Boolean, graphql_name="restored")
    """If an opsgenie incident was restored"""


class RemoveConnectionMutation(sgqlc.types.Type):
    """Remove an integration connection and deschedule any associated
    jobs
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class RemoveFromCollectionBlockList(sgqlc.types.Type):
    """Removes from the list of entities for which metadata collection is
    not allowed on this account.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class RemoveMonitorsLabels(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class RemoveUserFromAccount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("user",)
    user = sgqlc.types.Field("User", graphql_name="user")


class Report(sgqlc.types.Type):
    """Available report for an insight"""

    __schema__ = schema
    __field_names__ = ("name", "description")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of report"""

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")
    """Information about report content"""


class ReportStatus(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "report_job_uuid",
        "report_type",
        "report_arguments",
        "status",
        "error",
        "download_url",
    )
    report_job_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="reportJobUuid")

    report_type = sgqlc.types.Field(sgqlc.types.non_null(ReportTypeEnum), graphql_name="reportType")

    report_arguments = sgqlc.types.Field(
        sgqlc.types.non_null(ReportArgumentsInterface), graphql_name="reportArguments"
    )

    status = sgqlc.types.Field(sgqlc.types.non_null(ReportStatusEnum), graphql_name="status")

    error = sgqlc.types.Field(String, graphql_name="error")

    download_url = sgqlc.types.Field(String, graphql_name="downloadUrl")


class ResourceConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("ResourceEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class ResourceEdge(sgqlc.types.Type):
    """A Relay edge containing a `Resource` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("Resource", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class ResourceModification(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "type",
        "description",
        "resource_as_json",
        "is_significant_change",
        "diff_string",
        "resource_type",
        "resource_index",
    )
    type = sgqlc.types.Field(String, graphql_name="type")

    description = sgqlc.types.Field(String, graphql_name="description")

    resource_as_json = sgqlc.types.Field(String, graphql_name="resourceAsJson")

    is_significant_change = sgqlc.types.Field(Boolean, graphql_name="isSignificantChange")

    diff_string = sgqlc.types.Field(String, graphql_name="diffString")

    resource_type = sgqlc.types.Field(String, graphql_name="resourceType")

    resource_index = sgqlc.types.Field(Int, graphql_name="resourceIndex")


class ResponseURL(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("url", "created_at")
    url = sgqlc.types.Field(String, graphql_name="url")
    """Pre-signed URL for fetching report, expiration time is 1 minute"""

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """Report creation time in UTC"""


class RestartAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("restart_result",)
    restart_result = sgqlc.types.Field(GenericScalar, graphql_name="restartResult")
    """The result object returned from the agent."""


class RestoreCollectionStorage(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("storage",)
    storage = sgqlc.types.Field(CollectionStorage, graphql_name="storage")
    """The storage that was assigned"""


class RestoreCustomRule(sgqlc.types.Type):
    """Restore a custom rule"""

    __schema__ = schema
    __field_names__ = ("uuid",)
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")


class ResumeMonitorBootstrap(sgqlc.types.Type):
    """Resume the monitor bootstrapping process (for example, to continue
    loading historical data after an error occurs)
    """

    __schema__ = schema
    __field_names__ = ("monitor",)
    monitor = sgqlc.types.Field("MetricMonitoring", graphql_name="monitor")
    """The monitor whose bootstrapping was resumed"""


class RoleOutput(sgqlc.types.Type):
    """A named set of permissions that can be assigned to principals."""

    __schema__ = schema
    __field_names__ = ("name", "version", "is_managed", "label", "description")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Unique, human-readable name name with format of [company-
    name]/[role-name]
    """

    version = sgqlc.types.Field(String, graphql_name="version")
    """Version of the permissions definitions the group is designed for,
    ex: 2022-03-17. Defaults to current.
    """

    is_managed = sgqlc.types.Field(Boolean, graphql_name="isManaged")
    """Indicates if this role is managed by Monte Carlo. If so, it may
    not be modified by clients.
    """

    label = sgqlc.types.Field(String, graphql_name="label")
    """UI/user-friendly display name, ex: Editor"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description/help text to help users understand the purpose of the
    role
    """


class RoutingRuleData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "audience_uuid",
        "audience_label",
        "anomaly_types",
        "incident_sub_types",
        "table_rules",
        "table_id_rules",
        "tag_rules",
        "table_stats_rules",
        "asset_rules",
        "domain_rules",
        "exclude_domains",
        "digest_settings_id",
        "created_by_id",
        "last_update_user_id",
        "custom_message",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="uuid")

    audience_uuid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="audienceUuid")

    audience_label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="audienceLabel")

    anomaly_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="anomalyTypes"
    )

    incident_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="incidentSubTypes"
    )

    table_rules = sgqlc.types.Field(String, graphql_name="tableRules")

    table_id_rules = sgqlc.types.Field(GenericScalar, graphql_name="tableIdRules")

    tag_rules = sgqlc.types.Field(GenericScalar, graphql_name="tagRules")

    table_stats_rules = sgqlc.types.Field(GenericScalar, graphql_name="tableStatsRules")

    asset_rules = sgqlc.types.Field(GenericScalar, graphql_name="assetRules")

    domain_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="domainRules"
    )

    exclude_domains = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="excludeDomains"
    )

    digest_settings_id = sgqlc.types.Field(String, graphql_name="digestSettingsId")

    created_by_id = sgqlc.types.Field(Int, graphql_name="createdById")

    last_update_user_id = sgqlc.types.Field(Int, graphql_name="lastUpdateUserId")

    custom_message = sgqlc.types.Field(String, graphql_name="customMessage")


class RowCountResponseType(sgqlc.types.Type):
    """Row count info"""

    __schema__ = schema
    __field_names__ = ("query", "count", "approximate")
    query = sgqlc.types.Field(String, graphql_name="query")
    """SQL query used to fetch row count"""

    count = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="count")
    """Row count"""

    approximate = sgqlc.types.Field(Boolean, graphql_name="approximate")
    """Is this an approximate count?"""


class RunCustomRules(sgqlc.types.Type):
    """Run a list of custom rules manually"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class RunDailyCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("day", "run_count")
    day = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="day")
    """The date for the run count"""

    run_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="runCount")
    """The run count"""


class RunMonitor(sgqlc.types.Type):
    """Run a monitor manually"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")


class RunMonitors(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")


class RunSqlRule(sgqlc.types.Type):
    """Run a Custom SQL monitor manually"""

    __schema__ = schema
    __field_names__ = ("job_execution_uuids",)
    job_execution_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(UUID), graphql_name="jobExecutionUuids"
    )
    """DEPRECATED"""


class RunTableMonitorValidation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """True if initialized successfully"""


class SQLQueryResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("columns", "rows", "matches")
    columns = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="columns")

    rows = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.list_of(String)), graphql_name="rows")

    matches = sgqlc.types.Field(sgqlc.types.list_of(ConditionMatches), graphql_name="matches")


class SQLResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "columns",
        "rows",
        "matches",
        "query",
        "has_error",
        "error",
        "sampling_disabled",
        "sampling_restricted",
        "rate_limit_exceeded",
        "idempotent_status",
        "download_url",
        "query_execution_id",
    )
    columns = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="columns")

    rows = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.list_of(String)), graphql_name="rows")

    matches = sgqlc.types.Field(sgqlc.types.list_of(ConditionMatches), graphql_name="matches")

    query = sgqlc.types.Field(String, graphql_name="query")
    """The executed SQL query."""

    has_error = sgqlc.types.Field(Boolean, graphql_name="hasError")
    """If true, an error has occurred while executing the query and
    results mightnot be available. The error field might include
    additional details.
    """

    error = sgqlc.types.Field(String, graphql_name="error")
    """An error description if an error occurred while executing the
    query.
    """

    sampling_disabled = sgqlc.types.Field(Boolean, graphql_name="samplingDisabled")
    """Indicates if sampling has been disabled for the warehouse."""

    sampling_restricted = sgqlc.types.Field(Boolean, graphql_name="samplingRestricted")
    """Indicates if sampling has been restricted for the user."""

    rate_limit_exceeded = sgqlc.types.Field(Boolean, graphql_name="rateLimitExceeded")
    """Indicates if the rate limit was exceeded."""

    idempotent_status = sgqlc.types.Field(IdempotentStatus, graphql_name="idempotentStatus")

    download_url = sgqlc.types.Field(String, graphql_name="downloadUrl")
    """Link to download the query response."""

    query_execution_id = sgqlc.types.Field(String, graphql_name="queryExecutionId")
    """Unique ID associated to the executed query."""


class SamlIdentityProvider(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "federation_type",
        "cognito_name",
        "domains",
        "account_identifier",
        "default_authorization_groups",
        "metadata_url",
        "metadata",
    )
    federation_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="federationType")
    """SAML (constant)"""

    cognito_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cognitoName")
    """Cognito name / Identity Provider name"""

    domains = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="domains"
    )
    """A list of domains authorized by the IdP"""

    account_identifier = sgqlc.types.Field(String, graphql_name="accountIdentifier")
    """An account identifier authorized by the IdP"""

    default_authorization_groups = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="defaultAuthorizationGroups"
    )
    """List of authorization group names assigned to new SSO users by
    default.
    """

    metadata_url = sgqlc.types.Field(String, graphql_name="metadataUrl")
    """The URL of the metadata file"""

    metadata = sgqlc.types.Field(String, graphql_name="metadata")
    """The metadata in XML format"""


class SaveEventOnboardingData(sgqlc.types.Type):
    """Save event onboarding configuration"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the event onboarding data was saved successfully"""


class SaveSlackCredentialsMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("slack_credentials",)
    slack_credentials = sgqlc.types.Field("SlackCredentialsV2", graphql_name="slackCredentials")


class SaveTableImportanceStats(sgqlc.types.Type):
    """Save custom table stats for a table"""

    __schema__ = schema
    __field_names__ = ("stats",)
    stats = sgqlc.types.Field("TableImportanceStatsResponse", graphql_name="stats")


class ScalarChange(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("before", "after")
    before = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="before")
    """Value before change"""

    after = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="after")
    """Value after change"""


class ScheduleConfig(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "schedule_type",
        "dynamic_schedule_mcons",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_lag_minutes",
        "interval_crontab_day_or",
        "start_time",
        "timezone",
        "min_interval_minutes",
        "next_execution_time_override",
        "is_automatic",
    )
    schedule_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="scheduleType")

    dynamic_schedule_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="dynamicScheduleMcons"
    )

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="intervalCrontab"
    )

    interval_crontab_lag_minutes = sgqlc.types.Field(Int, graphql_name="intervalCrontabLagMinutes")

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")

    timezone = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timezone")

    min_interval_minutes = sgqlc.types.Field(Int, graphql_name="minIntervalMinutes")

    next_execution_time_override = sgqlc.types.Field(
        DateTime, graphql_name="nextExecutionTimeOverride"
    )

    is_automatic = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAutomatic")


class ScheduleConfigOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "schedule_type",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "start_time",
        "min_interval_minutes",
        "timezone",
        "is_automatic",
        "dynamic_schedule_mcons",
    )
    schedule_type = sgqlc.types.Field(
        sgqlc.types.non_null(ScheduleType), graphql_name="scheduleType"
    )
    """Type of schedule"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Time interval between job executions, in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """For schedule_type=fixed, one or more cron schedules to determine
    the next execution, each time uses the closest value of all
    schedules
    """

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """For schedule_type=fixed, the date the schedule should start"""

    min_interval_minutes = sgqlc.types.Field(Int, graphql_name="minIntervalMinutes")
    """For schedule_type=dynamic, the minimum time interval between job
    executions
    """

    timezone = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions."""

    is_automatic = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAutomatic")
    """If true, the schedule was automatically generated by Monte Carlo.
    If false, the schedule was configured by the user.
    """

    dynamic_schedule_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="dynamicScheduleMcons"
    )
    """Mcons of tables to trigger schedule on update"""


class SchemaChange(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "start_time", "fields_added", "fields_removed", "field_type_changes")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")

    fields_added = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="fieldsAdded",
    )

    fields_removed = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="fieldsRemoved",
    )

    field_type_changes = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FieldTypeChange))),
        graphql_name="fieldTypeChanges",
    )


class SchemaChangeConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("SchemaChangeEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class SchemaChangeEdge(sgqlc.types.Type):
    """A Relay edge containing a `SchemaChange` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(SchemaChange, graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class SchemaField(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "type", "mode", "nested", "sql_name", "main_type")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

    mode = sgqlc.types.Field(sgqlc.types.non_null(FieldMode), graphql_name="mode")

    nested = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="nested")

    sql_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlName")

    main_type = sgqlc.types.Field(sgqlc.types.non_null(FieldType), graphql_name="mainType")


class SearchResponse(sgqlc.types.Type):
    """List of search results that match the query"""

    __schema__ = schema
    __field_names__ = ("total_hits", "offset", "results", "facet_results")
    total_hits = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalHits")
    """Number of results"""

    offset = sgqlc.types.Field(Int, graphql_name="offset")
    """Offset for paginating results"""

    results = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("SearchResult")), graphql_name="results"
    )
    """List of matching results"""

    facet_results = sgqlc.types.Field(
        sgqlc.types.list_of(FacetResults), graphql_name="facetResults"
    )
    """Facet results"""


class SearchResult(sgqlc.types.Type):
    """An individual result. Part of the SearchResponse"""

    __schema__ = schema
    __field_names__ = (
        "mcon",
        "lineage_node_id",
        "object_type",
        "object_id",
        "display_name",
        "parent_mcon",
        "path",
        "project_id",
        "dataset",
        "table_id",
        "properties",
        "resource_id",
        "warehouse_display_name",
        "description",
        "field_type",
        "highlight",
        "highlight_properties",
        "field_names",
        "is_important",
        "importance_score",
        "upstream_resource_ids",
        "bi_parent_name",
        "is_monitored",
        "is_muted",
        "etl_type",
        "supports_data_explorer",
        "dbt_project_name",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """Monte Carlo full identifier for an entity"""

    lineage_node_id = sgqlc.types.Field(String, graphql_name="lineageNodeId")
    """Identifier for lineage nodes. Warning - To be deprecated soon"""

    object_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="objectType")
    """Type of object (e.g. table, view, etc.)"""

    object_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="objectId")
    """Partial identifier (e.g. project:dataset.table)"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Friendly name for entity"""

    parent_mcon = sgqlc.types.Field(String, graphql_name="parentMcon")
    """Identifier for any parents (e.g. field belonging to a table)"""

    path = sgqlc.types.Field(String, graphql_name="path")
    """Path to node"""

    project_id = sgqlc.types.Field(String, graphql_name="projectId")
    """Name of project (database or catalog in some warehouses)"""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Name of dataset (schema in some warehouses)"""

    table_id = sgqlc.types.Field(String, graphql_name="tableId")
    """Name of the table"""

    properties = sgqlc.types.Field(
        sgqlc.types.list_of("SearchResultProperty"), graphql_name="properties"
    )
    """Any attached labels"""

    resource_id = sgqlc.types.Field(String, graphql_name="resourceId")
    """Resource identifier (e.g. warehouse). Warning - To be deprecated
    soon
    """

    warehouse_display_name = sgqlc.types.Field(String, graphql_name="warehouseDisplayName")
    """Name of warehouse"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description of object"""

    field_type = sgqlc.types.Field(String, graphql_name="fieldType")
    """Data type of field. Only populated if object_type=field"""

    highlight = sgqlc.types.Field(sgqlc.types.list_of(HighlightSnippets), graphql_name="highlight")
    """Highlight snippets"""

    highlight_properties = sgqlc.types.Field(
        sgqlc.types.list_of(NestedHighlightSnippets), graphql_name="highlightProperties"
    )
    """Highlight snippets for object properties"""

    field_names = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="fieldNames")
    """Field names (if object_type=table)"""

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")
    """Whether the table or field is important"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """Importance score for tables"""

    upstream_resource_ids = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="upstreamResourceIds"
    )
    """Upstream resource ids"""

    bi_parent_name = sgqlc.types.Field(String, graphql_name="biParentName")
    """Name of parent resource to BI asset"""

    is_monitored = sgqlc.types.Field(Boolean, graphql_name="isMonitored")
    """Whether the table is monitored"""

    is_muted = sgqlc.types.Field(Boolean, graphql_name="isMuted")
    """Whether the table is muted"""

    etl_type = sgqlc.types.Field(EtlType, graphql_name="etlType")
    """ETL type of the job asset (if object_type=job)"""

    supports_data_explorer = sgqlc.types.Field(Boolean, graphql_name="supportsDataExplorer")
    """Whether the table supports data explorer"""

    dbt_project_name = sgqlc.types.Field(String, graphql_name="dbtProjectName")
    """Name of the dbt project for dbt-job assets"""


class SearchResultProperty(sgqlc.types.Type):
    """An individual label. Part of the SearchResult"""

    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of label"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Value of label"""


class SegmentCountQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query",)
    query = sgqlc.types.Field(String, graphql_name="query")
    """SQL query to collect segment count"""


class SegmentLabels(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_series_uuids", "labels", "last_label")
    time_series_uuids = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
        graphql_name="timeSeriesUuids",
    )

    labels = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="labels",
    )

    last_label = sgqlc.types.Field(String, graphql_name="lastLabel")
    """Value to use as 'after' for pagination"""


class SelectGitlabProjects(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class SendAlertInvite(sgqlc.types.Type):
    """Send an invitation to a non-user for an existing alert"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class SendDbtArtifactsEvent(sgqlc.types.Type):
    """Publish a Dbt artifacts event to Kinesis stream"""

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")


class SensitivityThreshold(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("level",)
    level = sgqlc.types.Field(SensitivityLevels, graphql_name="level")
    """Low, medium or high sensitivity"""


class ServiceNowChoiceOutput(sgqlc.types.Type):
    """A ServiceNow choice"""

    __schema__ = schema
    __field_names__ = ("value", "label")
    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """The choice value"""

    label = sgqlc.types.Field(String, graphql_name="label")
    """The choice label"""


class ServiceNowFieldOutput(sgqlc.types.Type):
    """A ServiceNow incident field"""

    __schema__ = schema
    __field_names__ = (
        "key",
        "label",
        "type",
        "max_length",
        "is_mandatory",
        "default_value",
        "reference_type",
        "choices",
    )
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """The field key"""

    label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label")
    """The field label"""

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")
    """The field type"""

    max_length = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="maxLength")
    """The field max length"""

    is_mandatory = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isMandatory")
    """If the field is mandatory"""

    default_value = sgqlc.types.Field(String, graphql_name="defaultValue")
    """The field default value"""

    reference_type = sgqlc.types.Field(String, graphql_name="referenceType")
    """The field reference type"""

    choices = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ServiceNowChoiceOutput)), graphql_name="choices"
    )
    """The choices for the field"""


class ServiceNowIncidentDetailsOutput(sgqlc.types.Type):
    """Incident details stored at ServiceNow"""

    __schema__ = schema
    __field_names__ = ("number", "link", "assigned_to", "state")
    number = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="number")
    """The user assigned to the incident"""

    link = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="link")
    """The link to see the incident in ServiceNow"""

    assigned_to = sgqlc.types.Field("ServiceNowUserOutput", graphql_name="assignedTo")
    """The user assigned to the incident"""

    state = sgqlc.types.Field("ServiceNowIncidentStateOutput", graphql_name="state")
    """The incident state"""


class ServiceNowIncidentOutput(sgqlc.types.Type):
    """A ServiceNow incident"""

    __schema__ = schema
    __field_names__ = (
        "id",
        "incident_sys_id",
        "incident_id",
        "integration_id",
        "notification",
        "create_warning",
        "details",
        "created_at",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="id")
    """The ID to identify the ServiceNow incident in Monte Carlo"""

    incident_sys_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="incidentSysId")
    """The incident sys_id for ServiceNow"""

    incident_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="incidentId")
    """The incident ID for Monte Carlo"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """The integration ID"""

    notification = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="notification")
    """Indicates if the ServiceNow incident was created from a Monte
    Carlo a notification
    """

    create_warning = sgqlc.types.Field(String, graphql_name="createWarning")
    """Any warning messages from Monte Carlo from the ServiceNow Incident
    creation
    """

    details = sgqlc.types.Field(ServiceNowIncidentDetailsOutput, graphql_name="details")
    """Incident details stored at ServiceNow"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")
    """When the incident was created"""


class ServiceNowIncidentStateOutput(sgqlc.types.Type):
    """A ServiceNow state"""

    __schema__ = schema
    __field_names__ = ("value", "label")
    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """The value for the state"""

    label = sgqlc.types.Field(String, graphql_name="label")
    """The label for the state"""


class ServiceNowIntegrationOptions(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "oauth_token_endpoint",
        "api_base_url",
        "incident_link_url_pattern",
        "supports_user_table",
        "supports_fetch_fields",
        "supports_fetch_incident",
        "set_description_field",
        "status_mappings",
    )
    oauth_token_endpoint = sgqlc.types.Field(String, graphql_name="oauthTokenEndpoint")

    api_base_url = sgqlc.types.Field(String, graphql_name="apiBaseUrl")

    incident_link_url_pattern = sgqlc.types.Field(String, graphql_name="incidentLinkUrlPattern")

    supports_user_table = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsUserTable"
    )

    supports_fetch_fields = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsFetchFields"
    )

    supports_fetch_incident = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsFetchIncident"
    )

    set_description_field = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="setDescriptionField"
    )

    status_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(MonteCarloStatusMapping)),
        graphql_name="statusMappings",
    )


class ServiceNowIntegrationOutput(sgqlc.types.Type):
    """A ServiceNow integration"""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "instance_name",
        "username",
        "credentials",
        "default_incident_fields",
        "default_alert_fields",
        "webhook_enabled",
        "webhook_url",
        "webhook_config",
        "options",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """A short name to identify the integration"""

    instance_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="instanceName")
    """The instance name for your ServiceNow site"""

    username = sgqlc.types.Field(String, graphql_name="username")
    """The ServiceNow username for basic authentication. DEPRECATED: Use
    credentials instead.
    """

    credentials = sgqlc.types.Field(
        sgqlc.types.non_null(ServiceNowCredentialsInterface), graphql_name="credentials"
    )
    """The configured credentials. Sensitive fields will be redacted."""

    default_incident_fields = sgqlc.types.Field(JSONString, graphql_name="defaultIncidentFields")
    """Default values for incident fields."""

    default_alert_fields = sgqlc.types.Field(JSONString, graphql_name="defaultAlertFields")
    """Default values for alert fields"""

    webhook_enabled = sgqlc.types.Field(Boolean, graphql_name="webhookEnabled")
    """Whether the ServiceNow webhook is enabled"""

    webhook_url = sgqlc.types.Field(String, graphql_name="webhookUrl")
    """('The ServiceNow webhook URL. Configure this as the target of your
    ServiceNow Webhook.',)
    """

    webhook_config = sgqlc.types.Field(
        "ServiceNowWebhookConfigOutput", graphql_name="webhookConfig"
    )
    """Webhook config"""

    options = sgqlc.types.Field(ServiceNowIntegrationOptions, graphql_name="options")
    """Options for ServiceNow integration"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the integration"""


class ServiceNowStateMappingOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("incident_feedback", "servicenow_incident_state")
    incident_feedback = sgqlc.types.Field(String, graphql_name="incidentFeedback")
    """('The feedback that will be set on the Monte Carlo incident if the
    ServiceNow incident is set to any of the provided ServiceNow
    statuses',)
    """

    servicenow_incident_state = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="servicenowIncidentState"
    )
    """The ServiceNow states that will map to the Monte Carlo incident
    feedback
    """


class ServiceNowTestCredentialsOutput(sgqlc.types.Type):
    """A ServiceNow test credentials result"""

    __schema__ = schema
    __field_names__ = ("valid_credentials",)
    valid_credentials = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="validCredentials"
    )
    """Returns if the credentials are valid"""


class ServiceNowUserOutput(sgqlc.types.Type):
    """A ServiceNow user details"""

    __schema__ = schema
    __field_names__ = ("sys_id", "user_id", "display_name", "email")
    sys_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sysId")
    """The user Sys Id"""

    user_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="userId")
    """The user ID"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """The user display name"""

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")
    """The user email"""


class ServiceNowWebhookConfigOutput(sgqlc.types.Type):
    """ServiceNow webhook config"""

    __schema__ = schema
    __field_names__ = ("state_mappings",)
    state_mappings = sgqlc.types.Field(
        sgqlc.types.list_of(ServiceNowStateMappingOutput), graphql_name="stateMappings"
    )
    """Mapping FROM ServiceNow incident states TO Monte Carlo alert
    status
    """


class SetAccountBillingPlan(sgqlc.types.Type):
    """Sets the billing plan for an account and create the customer in
    the billing vendor
    """

    __schema__ = schema
    __field_names__ = ("account",)
    account = sgqlc.types.Field(Account, graphql_name="account")


class SetAccountName(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("account",)
    account = sgqlc.types.Field(Account, graphql_name="account")


class SetAlertOwner(sgqlc.types.Type):
    """Set an owner for an existing alert"""

    __schema__ = schema
    __field_names__ = ("alert",)
    alert = sgqlc.types.Field("Alert", graphql_name="alert")
    """The updated alert"""


class SetAlertSeverity(sgqlc.types.Type):
    """By setting severity for an alert, the alert is declared an
    incident
    """

    __schema__ = schema
    __field_names__ = ("alert",)
    alert = sgqlc.types.Field("Alert", graphql_name="alert")
    """The updated alert/incident"""


class SetAssetCollectionPreferences(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "asset_collection_preferences")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""

    asset_collection_preferences = sgqlc.types.Field(
        "AssetCollectionPreferences", graphql_name="assetCollectionPreferences"
    )
    """The created or updated asset collection preferences."""


class SetAzureDevopsSourceSelections(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Always true. Response will contain errors on failure."""


class SetConnectionDeletionProtectionMutation(sgqlc.types.Type):
    """Set deletion protection for an integration connection"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class SetConnectionName(sgqlc.types.Type):
    """Set friendly name for a connection."""

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field(sgqlc.types.non_null(Connection), graphql_name="connection")
    """Connection where name was set."""


class SetCustomSqlSamplingSize(sgqlc.types.Type):
    """Set custom sql sampling data size."""

    __schema__ = schema
    __field_names__ = ("custom_sql_sampling_size",)
    custom_sql_sampling_size = sgqlc.types.Field(Int, graphql_name="customSqlSamplingSize")


class SetDataLakeCatalogMappings(sgqlc.types.Type):
    """Set database lake catalog mappings for a connection.This is used
    to override the database name during table resolution.Note: Only
    supported for dbt connections
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class SetDefaultAlertGroupInterval(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("warehouse_config",)
    warehouse_config = sgqlc.types.Field(JSONString, graphql_name="warehouseConfig")
    """Warehouse configuration."""


class SetDefaultFailureAudiences(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class SetDefaultIncidentGroupInterval(sgqlc.types.Type):
    """Set default incident grouping interval (in hours) for a warehouse."""

    __schema__ = schema
    __field_names__ = ("warehouse_config",)
    warehouse_config = sgqlc.types.Field(JSONString, graphql_name="warehouseConfig")
    """Warehouse configuration."""


class SetDefaultLineageAlertGrouping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Warehouse lineage grouping status."""


class SetDefaultLineageIncidentGrouping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Warehouse lineage grouping status."""


class SetEtlContainerName(sgqlc.types.Type):
    """Set friendly name for a ETL container."""

    __schema__ = schema
    __field_names__ = ("etl_container",)
    etl_container = sgqlc.types.Field(EtlContainer, graphql_name="etlContainer")
    """ETL container where name was set."""


class SetEtlJobGeneratesAlerts(sgqlc.types.Type):
    """Set whether a given ETL job (like an Airflow DAG) generates alerts
    or not
    """

    __schema__ = schema
    __field_names__ = ("generates_alerts",)
    generates_alerts = sgqlc.types.Field(Boolean, graphql_name="generatesAlerts")
    """New value for generates_alerts"""


class SetEtlJobGeneratesIncidents(sgqlc.types.Type):
    """Set whether a given ETL job (like an Airflow DAG) generates
    incidents or not
    """

    __schema__ = schema
    __field_names__ = ("generates_incidents",)
    generates_incidents = sgqlc.types.Field(Boolean, graphql_name="generatesIncidents")
    """New value for generates_incidents"""


class SetEventDetectorFeedback(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("feedback",)
    feedback = sgqlc.types.Field("EventDetectorFeedback", graphql_name="feedback")
    """Feedback for the detector about the event"""


class SetEventDetectorFeedbackByAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("completed",)
    completed = sgqlc.types.Field(Boolean, graphql_name="completed")


class SetGroupRepetitiveDbtModelFailures(sgqlc.types.Type):
    """Set whether to group dbt model failures with the same error
    message into the same incident
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field(Connection, graphql_name="connection")


class SetGroupRepetitiveDbtSeedFailures(sgqlc.types.Type):
    """Set whether to group dbt seed failures with the same error message
    into the same incident
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field(Connection, graphql_name="connection")


class SetGroupRepetitiveDbtSnapshotFailures(sgqlc.types.Type):
    """Set whether to group dbt snapshot failures with the same error
    message into the same incident
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field(Connection, graphql_name="connection")


class SetGroupRepetitiveDbtTestFailures(sgqlc.types.Type):
    """Set whether to group dbt test failures with the same error message
    into the same incident
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field(Connection, graphql_name="connection")


class SetGroupRepetitiveDbtTestWarnings(sgqlc.types.Type):
    """Set whether to group dbt test warnings with the same error message
    into the same incident
    """

    __schema__ = schema
    __field_names__ = ("connection",)
    connection = sgqlc.types.Field(Connection, graphql_name="connection")


class SetIncidentFeedbackPayload(sgqlc.types.Type):
    """Provide feedback for an incident"""

    __schema__ = schema
    __field_names__ = ("incident", "client_mutation_id")
    incident = sgqlc.types.Field("Incident", graphql_name="incident")
    """Incident details, for which feedback was given"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class SetIncidentFeedbackV2Payload(sgqlc.types.Type):
    """Provide feedback for an incident"""

    __schema__ = schema
    __field_names__ = ("incident", "client_mutation_id")
    incident = sgqlc.types.Field("Incident", graphql_name="incident")
    """Incident details, for which feedback was given"""

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class SetIncidentOwner(sgqlc.types.Type):
    """Set an owner for an existing incident"""

    __schema__ = schema
    __field_names__ = ("incident",)
    incident = sgqlc.types.Field("Incident", graphql_name="incident")
    """The updated incident"""


class SetIncidentSeverity(sgqlc.types.Type):
    """Set severity for an existing incident"""

    __schema__ = schema
    __field_names__ = ("incident",)
    incident = sgqlc.types.Field("Incident", graphql_name="incident")
    """The updated incident"""


class SetIntegrationName(sgqlc.types.Type):
    """Set friendly name for an integration."""

    __schema__ = schema
    __field_names__ = ("integration",)
    integration = sgqlc.types.Field(
        sgqlc.types.non_null(IntegrationUpdateResult), graphql_name="integration"
    )
    """Integration where name was set."""


class SetJobGeneratesAlerts(sgqlc.types.Type):
    """Set whether a dbt job generates alerts"""

    __schema__ = schema
    __field_names__ = ("dbt_job",)
    dbt_job = sgqlc.types.Field("DbtJob", graphql_name="dbtJob")


class SetJobGeneratesIncidents(sgqlc.types.Type):
    """Set whether a dbt job generates incidents"""

    __schema__ = schema
    __field_names__ = ("dbt_job",)
    dbt_job = sgqlc.types.Field("DbtJob", graphql_name="dbtJob")


class SetMaxTimeSeries(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class SetPiiFilterStatus(sgqlc.types.Type):
    """Set PII filter status for this account."""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class SetProjectGenerateAlertsForModelFailures(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateAlertsForSeedFailures(sgqlc.types.Type):
    """Set whether a dbt project generates alerts for seed failures"""

    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateAlertsForSnapshotFailures(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateAlertsForTestFailures(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateAlertsForTestWarnings(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateIncidentsForModelFailures(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateIncidentsForTestFailures(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetProjectGenerateIncidentsForTestWarnings(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("dbt_project",)
    dbt_project = sgqlc.types.Field("DbtProject", graphql_name="dbtProject")


class SetSensitivity(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class SetTutorialState(sgqlc.types.Type):
    """Set the state of a tutorial step"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Step status change success"""


class SetWarehouseName(sgqlc.types.Type):
    """Set friendly name for a warehouse."""

    __schema__ = schema
    __field_names__ = ("warehouse",)
    warehouse = sgqlc.types.Field("Warehouse", graphql_name="warehouse")
    """Warehouse where name was set."""


class SetWildcardTemplates(sgqlc.types.Type):
    """Sets the templates to use for wildcard aggregation (overrides
    existing templates)
    """

    __schema__ = schema
    __field_names__ = ("templates",)
    templates = sgqlc.types.Field(sgqlc.types.list_of("WildcardTemplate"), graphql_name="templates")


class SetWorkspacesAllowListForPowerBiReportsCollection(sgqlc.types.Type):
    """Set the list of workspaces for which metadata collection is
    allowed on this account.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class SharedQueryOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query", "variables")
    query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="query")
    """GraphQL query"""

    variables = sgqlc.types.Field(sgqlc.types.non_null(GenericScalar), graphql_name="variables")
    """GraphQL query variables"""


class SheetDashboardRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "path",
        "created_at",
        "updated_at",
        "id",
        "dashboard_id",
        "dashboard_title",
    )
    name = sgqlc.types.Field(String, graphql_name="name")

    path = sgqlc.types.Field(String, graphql_name="path")

    created_at = sgqlc.types.Field(String, graphql_name="createdAt")

    updated_at = sgqlc.types.Field(String, graphql_name="updatedAt")

    id = sgqlc.types.Field(String, graphql_name="id")

    dashboard_id = sgqlc.types.Field(String, graphql_name="dashboardId")

    dashboard_title = sgqlc.types.Field(String, graphql_name="dashboardTitle")


class SiteRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "uri")
    name = sgqlc.types.Field(String, graphql_name="name")

    uri = sgqlc.types.Field(String, graphql_name="uri")


class Size(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "metric",
        "ucs_upper",
        "ucs_lower",
        "ucs_threshold_low",
        "ucs_threshold_medium",
        "ucs_threshold_high",
        "ucs_min_size_change",
        "ucs_reason",
        "ucs_status",
        "sd_upper",
        "sd_lower",
        "sd_reason",
        "sd_status",
        "last_size_change",
        "detector_threshold",
        "sd_upper_high",
        "sd_lower_high",
        "sd_upper_medium",
        "sd_lower_medium",
        "sd_upper_low",
        "sd_lower_low",
    )
    metric = sgqlc.types.Field(String, graphql_name="metric")
    """The type of size metric. (Values: "total_byte_count",
    "total_row_count", "write_throughput")
    """

    ucs_upper = sgqlc.types.Field(Float, graphql_name="ucsUpper")
    """Deprecated: Unchanged size upper threshold"""

    ucs_lower = sgqlc.types.Field(Float, graphql_name="ucsLower")
    """Deprecated: Unchanged size lower threshold"""

    ucs_threshold_low = sgqlc.types.Field(Float, graphql_name="ucsThresholdLow")
    """Unchanged size "low" level threshold"""

    ucs_threshold_medium = sgqlc.types.Field(Float, graphql_name="ucsThresholdMedium")
    """Unchanged size "medium" level threshold"""

    ucs_threshold_high = sgqlc.types.Field(Float, graphql_name="ucsThresholdHigh")
    """Unchanged size "high" level threshold"""

    ucs_min_size_change = sgqlc.types.Field(Float, graphql_name="ucsMinSizeChange")
    """Deprecated: Minimal difference in size to be considered a change"""

    ucs_reason = sgqlc.types.Field(String, graphql_name="ucsReason")
    """Reason for not providing the ucs threshold"""

    ucs_status = sgqlc.types.Field(DetectorStatus, graphql_name="ucsStatus")
    """Status of the unchanged size detector"""

    sd_upper = sgqlc.types.Field(Float, graphql_name="sdUpper")
    """Deprecated: Size diff upper threshold"""

    sd_lower = sgqlc.types.Field(Float, graphql_name="sdLower")
    """Deprecated: Size diff lower threshold"""

    sd_reason = sgqlc.types.Field(String, graphql_name="sdReason")
    """Reason for not providing the sd threshold"""

    sd_status = sgqlc.types.Field(DetectorStatus, graphql_name="sdStatus")
    """Status of the size diff detector"""

    last_size_change = sgqlc.types.Field(LastSizeChange, graphql_name="lastSizeChange")
    """Deprecated, use getMetricsV4: Time and volume of the last
    significant change
    """

    detector_threshold = sgqlc.types.Field(Float, graphql_name="detectorThreshold")
    """Deprecated: The threshold calculated by the detector model"""

    sd_upper_high = sgqlc.types.Field(Float, graphql_name="sdUpperHigh")
    """Size diff upper High Sensitivity threshold"""

    sd_lower_high = sgqlc.types.Field(Float, graphql_name="sdLowerHigh")
    """Size diff lower High Sensitivity threshold"""

    sd_upper_medium = sgqlc.types.Field(Float, graphql_name="sdUpperMedium")
    """Size diff upper Medium Sensitivity threshold"""

    sd_lower_medium = sgqlc.types.Field(Float, graphql_name="sdLowerMedium")
    """Size diff lower Medium Sensitivity threshold"""

    sd_upper_low = sgqlc.types.Field(Float, graphql_name="sdUpperLow")
    """Size diff upper Low Sensitivity threshold"""

    sd_lower_low = sgqlc.types.Field(Float, graphql_name="sdLowerLow")
    """Size diff lower Low Sensitivity threshold"""


class SizeCollectionConfiguration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "enabled",
        "where_condition",
        "collection_status",
        "collection_error",
        "connection_id",
    )
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """True if collection is enabled. False if disabled"""

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")
    """Where condition which is applied to the collection query"""

    collection_status = sgqlc.types.Field(JobExecutionStatus, graphql_name="collectionStatus")
    """Status of the latest collection run. Adjust the where condition if
    the run failed or timed-out
    """

    collection_error = sgqlc.types.Field(String, graphql_name="collectionError")
    """Contains the error message if the latest collection run failed"""

    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """The connection ID where the size collector is run on."""


class SizeCollectionQuery(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("query",)
    query = sgqlc.types.Field(String, graphql_name="query")
    """Query executed by size collection"""


class SlackChannel(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "id", "topic", "purpose")
    name = sgqlc.types.Field(String, graphql_name="name")

    id = sgqlc.types.Field(String, graphql_name="id")

    topic = sgqlc.types.Field(String, graphql_name="topic")

    purpose = sgqlc.types.Field(String, graphql_name="purpose")


class SlackChannelResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("channels",)
    channels = sgqlc.types.Field(sgqlc.types.list_of(SlackChannel), graphql_name="channels")


class SlackChannelV2Connection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("SlackChannelV2Edge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class SlackChannelV2Edge(sgqlc.types.Type):
    """A Relay edge containing a `SlackChannelV2` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("SlackChannelV2", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class SlackConfig(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("broadcast_updates",)
    broadcast_updates = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="broadcastUpdates"
    )


class SlackCredentials(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "account",
        "credentials_s3_key",
        "team_id",
        "team_name",
        "reply_warning",
        "config",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    credentials_s3_key = sgqlc.types.Field(String, graphql_name="credentialsS3Key")

    team_id = sgqlc.types.Field(String, graphql_name="teamId")

    team_name = sgqlc.types.Field(String, graphql_name="teamName")

    reply_warning = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="replyWarning")

    config = sgqlc.types.Field(sgqlc.types.non_null(SlackConfig), graphql_name="config")


class SlackCredentialsV2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("id", "account", "installed_by", "slack_app_type", "reply_warning", "config")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    installed_by = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="installedBy")
    """User that installed the Slack app"""

    slack_app_type = sgqlc.types.Field(
        sgqlc.types.non_null(SlackCredentialsV2ModelSlackAppType), graphql_name="slackAppType"
    )
    """Type of Slack app"""

    reply_warning = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="replyWarning")

    config = sgqlc.types.Field(JSONString, graphql_name="config")


class SlackEngagementConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("SlackEngagementEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class SlackEngagementEdge(sgqlc.types.Type):
    """A Relay edge containing a `SlackEngagement` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("SlackEngagement", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class SlackMessageDetailsConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("SlackMessageDetailsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class SlackMessageDetailsEdge(sgqlc.types.Type):
    """A Relay edge containing a `SlackMessageDetails` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("SlackMessageDetails", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class SlackOauthUrlResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("url",)
    url = sgqlc.types.Field(String, graphql_name="url")


class SlackUserGroupListOutput(sgqlc.types.Type):
    """Response for listing Slack user groups."""

    __schema__ = schema
    __field_names__ = ("usergroups",)
    usergroups = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SlackUserGroupOutput"))),
        graphql_name="usergroups",
    )
    """List of all user groups"""


class SlackUserGroupOutput(sgqlc.types.Type):
    """Slack user group information."""

    __schema__ = schema
    __field_names__ = ("id", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Slack user group ID"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """User group name"""


class SlackUserListOutput(sgqlc.types.Type):
    """Paginated response for listing Slack users."""

    __schema__ = schema
    __field_names__ = ("users", "next_cursor")
    users = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SlackUserOutput"))),
        graphql_name="users",
    )
    """List of users in this page"""

    next_cursor = sgqlc.types.Field(String, graphql_name="nextCursor")
    """Cursor for next page (null if no more pages)"""


class SlackUserOutput(sgqlc.types.Type):
    """Slack user information."""

    __schema__ = schema
    __field_names__ = ("id", "display_name")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Slack user ID"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Display name"""


class SnoozeCustomRule(sgqlc.types.Type):
    """Snooze a custom rule. Data collection will continue, but no
    anomalies will be reported.
    """

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class SnoozeCustomRules(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("custom_rules",)
    custom_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("CustomRule")), graphql_name="customRules"
    )


class SnoozeDbtNode(sgqlc.types.Type):
    """Snooze a DBT node (model/test). Data collection will continue, but
    no events will be reported.
    """

    __schema__ = schema
    __field_names__ = ("node",)
    node = sgqlc.types.Field("DbtNode", graphql_name="node")


class SourceColumn(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("column_name", "column_type")
    column_name = sgqlc.types.Field(String, graphql_name="columnName")
    """Name of the source column"""

    column_type = sgqlc.types.Field(String, graphql_name="columnType")
    """Type of the source column"""


class SplitAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("alert_uuid",)
    alert_uuid = sgqlc.types.Field(UUID, graphql_name="alertUuid")


class SplitIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("incident_uuid",)
    incident_uuid = sgqlc.types.Field(UUID, graphql_name="incidentUuid")


class SqlBlockEvaluationResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "errors",
        "sql",
        "row_count",
        "data_source_sql",
        "fragments",
        "transform_queries",
    )
    errors = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Error))),
        graphql_name="errors",
    )

    sql = sgqlc.types.Field(String, graphql_name="sql")

    row_count = sgqlc.types.Field(Int, graphql_name="rowCount")

    data_source_sql = sgqlc.types.Field(String, graphql_name="dataSourceSql")

    fragments = sgqlc.types.Field(GenericScalar, graphql_name="fragments")

    transform_queries = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="transformQueries"
    )


class SqlExpression(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("expression",)
    expression = sgqlc.types.Field(String, graphql_name="expression")


class SqlParsedTable(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "mcon")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Table name parsed from query"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON resolved to parsed table"""


class SqlParserResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sources", "destination", "errors")
    sources = sgqlc.types.Field(sgqlc.types.list_of(SqlParsedTable), graphql_name="sources")
    """Parsed query sources"""

    destination = sgqlc.types.Field(SqlParsedTable, graphql_name="destination")
    """Parsed query destination"""

    errors = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="errors")
    """SQL parser errors"""


class SqlQueryTable(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("full_table_id", "mcon")
    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")
    """Full table id of the table"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCONs of the table"""


class SsoDetails(sgqlc.types.Type):
    """SSO information"""

    __schema__ = schema
    __field_names__ = ("entity_id", "sso_url")
    entity_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="entityId")
    """SSO Entity ID"""

    sso_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ssoUrl")
    """ACS endpoint URL / SSO URL"""


class StartDatabricksWarehouse(sgqlc.types.Type):
    """Start Databricks Warehouse."""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully."""


class StopMonitor(sgqlc.types.Type):
    """Deprecated: use DeleteMonitor instead"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class StreamingCluster(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "deleted_at",
        "uuid",
        "external_cluster_id",
        "name",
        "cluster_type",
        "streaming_system_uuid",
        "connections",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the streaming cluster."""

    external_cluster_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="externalClusterId"
    )
    """Cluster ID in the external system."""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the streaming system."""

    cluster_type = sgqlc.types.Field(
        sgqlc.types.non_null(StreamingClusterModelClusterType), graphql_name="clusterType"
    )
    """Cluster type."""

    streaming_system_uuid = sgqlc.types.Field(
        sgqlc.types.non_null(UUID), graphql_name="streamingSystemUuid"
    )
    """UUID of system that this cluster belongs to."""

    connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connections",
    )


class StreamingSystem(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "deleted_at",
        "uuid",
        "name",
        "type",
        "account_uuid",
        "dc_id",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the Streaming system."""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of the streaming system."""

    type = sgqlc.types.Field(sgqlc.types.non_null(StreamingSystemModelType), graphql_name="type")
    """Streaming system type."""

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")
    """Account identifier, maps to an account UUID."""

    dc_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dcId")
    """Maps to a data collector UUID."""


class StreamingSystemWithClusters(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("system", "cluster_connections")
    system = sgqlc.types.Field(StreamingSystem, graphql_name="system")

    cluster_connections = sgqlc.types.Field(
        sgqlc.types.list_of(Connection), graphql_name="clusterConnections"
    )


class SupportedTableValidationsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("supported_validations",)
    supported_validations = sgqlc.types.Field(
        sgqlc.types.list_of("TableValidation"), graphql_name="supportedValidations"
    )
    """A list of supported asset validations."""


class SupportedValidationsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("supported_validations",)
    supported_validations = sgqlc.types.Field(
        sgqlc.types.list_of("Validation"), graphql_name="supportedValidations"
    )
    """A list of supported validations."""


class SupportedWidget(sgqlc.types.Type):
    """Describes a field that can be visualized as a widget"""

    __schema__ = schema
    __field_names__ = ("field_name", "widget_type", "is_time_axis")
    field_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldName")
    """Field name"""

    widget_type = sgqlc.types.Field(sgqlc.types.non_null(WidgetType), graphql_name="widgetType")
    """Widget type"""

    is_time_axis = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isTimeAxis")
    """Whether or not this field is configured as a time axis"""


class SwitchUserAccount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("new_account",)
    new_account = sgqlc.types.Field(Account, graphql_name="newAccount")


class SyncMonitorsToCollibra(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("job_id",)
    job_id = sgqlc.types.Field(UUID, graphql_name="jobId")


class TSAAvailability(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("enabled", "reasons", "unsupported_alert_types", "supported_alert_sub_types")
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """If true, the Troubleshooting Agent is available to the
    user/account
    """

    reasons = sgqlc.types.Field(sgqlc.types.list_of(DenialReason), graphql_name="reasons")
    """Reasons if Troubleshooting Agent not available"""

    unsupported_alert_types = sgqlc.types.Field(
        sgqlc.types.list_of(AlertType), graphql_name="unsupportedAlertTypes"
    )
    """Alert types supported by Troubleshooting Agent"""

    supported_alert_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(AlertSubType), graphql_name="supportedAlertSubTypes"
    )
    """Alert sub types supported by Troubleshooting Agent"""


class TableAnomalyConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TableAnomalyEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TableAnomalyEdge(sgqlc.types.Type):
    """A Relay edge containing a `TableAnomaly` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TableAnomaly", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableCapabilitesWithReasonField(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("is_supported", "reason")
    is_supported = sgqlc.types.Field(Boolean, graphql_name="isSupported")

    reason = sgqlc.types.Field(String, graphql_name="reason")


class TableCapabilitiesResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "supports_freshness",
        "supports_bytes",
        "supports_rows",
        "supports_write_throughput",
        "supports_query_logs",
        "supports_lineage",
        "supports_lineage_pipeline",
        "supports_field_lineage",
        "supports_objects_deleted",
        "supports_total_row_count_change",
        "supports_dynamic_schedule",
        "supports_delta_logs",
        "supports_schema",
        "supports_validation_monitor",
        "supports_stats_monitor",
        "supports_comparison_monitor",
        "supports_categories_monitor",
        "supports_hourly_stats_monitor",
        "supports_json_schema_monitor",
        "supports_volume_slo",
        "supports_freshness_slo",
        "supports_custom_sql_rule",
        "supports_field_quality_rule",
        "supports_volume",
        "supports_non_metadata_size_collection",
        "supports_cross_db_comparison_rule",
        "supports_referential_integrity_rule",
        "supports_cardinality_rule",
        "supports_data_explorer",
        "supports_freshness_with_reason",
        "supports_bytes_with_reason",
        "supports_rows_with_reason",
        "supports_write_throughput_with_reason",
        "supports_query_logs_with_reason",
        "supports_lineage_with_reason",
        "supports_lineage_pipeline_with_reason",
        "supports_field_lineage_with_reason",
        "supports_objects_deleted_with_reason",
        "supports_total_row_count_change_with_reason",
        "supports_dynamic_schedule_with_reason",
        "supports_delta_logs_with_reason",
        "supports_schema_with_reason",
        "supports_stats_monitor_with_reason",
        "supports_comparison_monitor_with_reason",
        "supports_categories_monitor_with_reason",
        "supports_validation_monitor_with_reason",
        "supports_hourly_stats_monitor_with_reason",
        "supports_json_schema_monitor_with_reason",
        "supports_volume_slo_with_reason",
        "supports_freshness_slo_with_reason",
        "supports_custom_sql_rule_with_reason",
        "supports_field_quality_rule_with_reason",
        "supports_volume_with_reason",
        "supports_non_metadata_size_collection_with_reason",
        "supports_cross_db_comparison_rule_with_reason",
        "supports_referential_integrity_rule_with_reason",
        "supports_cardinality_rule_with_reason",
        "supports_data_explorer_with_reason",
        "supports_airflow_with_reason",
        "supports_dbt_with_reason",
        "supports_databricks_workflow_with_reason",
        "supports_fivetran_with_reason",
        "supports_azure_data_factory_with_reason",
        "supports_informatica_with_reason",
        "has_bytes",
        "has_freshness",
        "has_objects_deleted",
        "has_rows",
        "has_total_row_count_change",
        "has_write_throughput",
        "has_non_metadata_size_collection",
    )
    supports_freshness = sgqlc.types.Field(Boolean, graphql_name="supportsFreshness")
    """indicates whether the table could possibly have freshness"""

    supports_bytes = sgqlc.types.Field(Boolean, graphql_name="supportsBytes")
    """indicates whether the table could possibly provide events with
    byte counts
    """

    supports_rows = sgqlc.types.Field(Boolean, graphql_name="supportsRows")
    """indicates whether the table could possibly provide events with
    number of rows
    """

    supports_write_throughput = sgqlc.types.Field(Boolean, graphql_name="supportsWriteThroughput")
    """indicates whether the table could possibly provide write
    throughput events
    """

    supports_query_logs = sgqlc.types.Field(Boolean, graphql_name="supportsQueryLogs")
    """indicates whether the table could possibly provide query logs"""

    supports_lineage = sgqlc.types.Field(Boolean, graphql_name="supportsLineage")
    """indicates whether the table could possibly provide lineage"""

    supports_lineage_pipeline = sgqlc.types.Field(Boolean, graphql_name="supportsLineagePipeline")
    """indicates whether the table could possibly provide lineage
    pipeline events
    """

    supports_field_lineage = sgqlc.types.Field(Boolean, graphql_name="supportsFieldLineage")
    """indicates whether the table could possibly provide field lineage"""

    supports_objects_deleted = sgqlc.types.Field(Boolean, graphql_name="supportsObjectsDeleted")
    """indicates whether the table could possibly provide the number of
    objects deleted
    """

    supports_total_row_count_change = sgqlc.types.Field(
        Boolean, graphql_name="supportsTotalRowCountChange"
    )
    """indicates whether the table could possibly provide
    total_row_count_change events
    """

    supports_dynamic_schedule = sgqlc.types.Field(Boolean, graphql_name="supportsDynamicSchedule")
    """indicates whether the table could supports a dynamic schedule"""

    supports_delta_logs = sgqlc.types.Field(Boolean, graphql_name="supportsDeltaLogs")
    """indicates whether the table could supports delta history logs"""

    supports_schema = sgqlc.types.Field(Boolean, graphql_name="supportsSchema")
    """indicates whether the table supports schema"""

    supports_validation_monitor = sgqlc.types.Field(
        Boolean, graphql_name="supportsValidationMonitor"
    )
    """indicates whether the table could possibly be used for defining
    validation monitors
    """

    supports_stats_monitor = sgqlc.types.Field(Boolean, graphql_name="supportsStatsMonitor")
    """indicates whether the table could possibly be used for defining
    metric monitors
    """

    supports_comparison_monitor = sgqlc.types.Field(
        Boolean, graphql_name="supportsComparisonMonitor"
    )
    """indicates whether the table could possibly be used for defining
    comparison monitors
    """

    supports_categories_monitor = sgqlc.types.Field(
        Boolean, graphql_name="supportsCategoriesMonitor"
    )
    """indicates whether the table could possibly be used for defining
    category monitors
    """

    supports_hourly_stats_monitor = sgqlc.types.Field(
        Boolean, graphql_name="supportsHourlyStatsMonitor"
    )
    """indicates whether the table could possibly be used for defining
    hourly stats monitors (DEPRECATED)
    """

    supports_json_schema_monitor = sgqlc.types.Field(
        Boolean, graphql_name="supportsJsonSchemaMonitor"
    )
    """indicates whether the table could possibly be used for defining
    json schema monitors
    """

    supports_volume_slo = sgqlc.types.Field(Boolean, graphql_name="supportsVolumeSlo")
    """indicates whether the table could possibly be used for defining
    volume rules
    """

    supports_freshness_slo = sgqlc.types.Field(Boolean, graphql_name="supportsFreshnessSlo")
    """indicates whether the table could possibly be used for defining
    freshness rules
    """

    supports_custom_sql_rule = sgqlc.types.Field(Boolean, graphql_name="supportsCustomSqlRule")
    """indicates whether the table could possibly be used for defining
    custom sql rules
    """

    supports_field_quality_rule = sgqlc.types.Field(
        Boolean, graphql_name="supportsFieldQualityRule"
    )
    """DEPRECATED: always returns false"""

    supports_volume = sgqlc.types.Field(Boolean, graphql_name="supportsVolume")
    """Indicates whether the table could possibly have any volume metrics"""

    supports_non_metadata_size_collection = sgqlc.types.Field(
        Boolean, graphql_name="supportsNonMetadataSizeCollection"
    )
    """Indicates whether the table could support non-metadata size
    collection
    """

    supports_cross_db_comparison_rule = sgqlc.types.Field(
        Boolean, graphql_name="supportsCrossDbComparisonRule"
    )
    """Indicates whether the table could support cross-database
    comparison rules
    """

    supports_referential_integrity_rule = sgqlc.types.Field(
        Boolean, graphql_name="supportsReferentialIntegrityRule"
    )
    """Indicates whether the table could support referential integrity
    rules
    """

    supports_cardinality_rule = sgqlc.types.Field(Boolean, graphql_name="supportsCardinalityRule")
    """Indicates whether the table could support cardinality rules"""

    supports_data_explorer = sgqlc.types.Field(Boolean, graphql_name="supportsDataExplorer")
    """Indicates whether the table could support analysis using the Data
    Explorer
    """

    supports_freshness_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsFreshnessWithReason"
    )
    """indicates whether the table could possibly have freshness, and why"""

    supports_bytes_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsBytesWithReason"
    )
    """indicates whether the table could possibly provide events with
    byte counts, and why
    """

    supports_rows_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsRowsWithReason"
    )
    """indicates whether the table could possibly provide events with
    number of rows, and why
    """

    supports_write_throughput_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsWriteThroughputWithReason"
    )
    """indicates whether the table could possibly provide write
    throughput events, and why
    """

    supports_query_logs_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsQueryLogsWithReason"
    )
    """indicates whether the table could possibly provide query logs, and
    why
    """

    supports_lineage_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsLineageWithReason"
    )
    """indicates whether the table could possibly provide lineage, and
    why
    """

    supports_lineage_pipeline_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsLineagePipelineWithReason"
    )
    """indicates whether the table could possibly provide lineage
    pipeline events, and why
    """

    supports_field_lineage_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsFieldLineageWithReason"
    )
    """indicates whether the table could possibly provide field lineage,
    and why
    """

    supports_objects_deleted_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsObjectsDeletedWithReason"
    )
    """indicates whether the table could possibly provide the number of
    objects deleted, and why
    """

    supports_total_row_count_change_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsTotalRowCountChangeWithReason"
    )
    """indicates whether the table could possibly provide
    total_row_count_change events, and why
    """

    supports_dynamic_schedule_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsDynamicScheduleWithReason"
    )
    """indicates whether the table could supports a dynamic schedule, and
    why
    """

    supports_delta_logs_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsDeltaLogsWithReason"
    )
    """indicates whether the table could supports delta history logs, and
    why
    """

    supports_schema_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsSchemaWithReason"
    )
    """indicates whether the table supports schema, and why"""

    supports_stats_monitor_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsStatsMonitorWithReason"
    )
    """indicates whether the table could possibly be used for defining
    metric monitors, and why
    """

    supports_comparison_monitor_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsComparisonMonitorWithReason"
    )
    """indicates whether the table could possibly be used for defining
    comparison monitors, and why
    """

    supports_categories_monitor_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsCategoriesMonitorWithReason"
    )
    """indicates whether the table could possibly be used for defining
    category monitors, and why
    """

    supports_validation_monitor_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsValidationMonitorWithReason"
    )
    """indicates whether the table could possibly be used for defining a
    validation monitors, and why
    """

    supports_hourly_stats_monitor_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsHourlyStatsMonitorWithReason"
    )
    """indicates whether the table could possibly be used for defining
    hourly stats monitors (DEPRECATED), and why
    """

    supports_json_schema_monitor_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsJsonSchemaMonitorWithReason"
    )
    """indicates whether the table could possibly be used for defining
    json schema monitors, and why
    """

    supports_volume_slo_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsVolumeSloWithReason"
    )
    """indicates whether the table could possibly be used for defining
    volume rules, and why
    """

    supports_freshness_slo_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsFreshnessSloWithReason"
    )
    """indicates whether the table could possibly be used for defining
    freshness rules, and why
    """

    supports_custom_sql_rule_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsCustomSqlRuleWithReason"
    )
    """indicates whether the table could possibly be used for defining
    custom sql rules, and why
    """

    supports_field_quality_rule_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsFieldQualityRuleWithReason"
    )
    """DEPRECATED"""

    supports_volume_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsVolumeWithReason"
    )
    """Indicates whether the table could possibly have any volume
    metrics, and why
    """

    supports_non_metadata_size_collection_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsNonMetadataSizeCollectionWithReason"
    )
    """Indicates whether the table could support non-metadata size
    collection, and why
    """

    supports_cross_db_comparison_rule_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsCrossDbComparisonRuleWithReason"
    )
    """Indicates whether the table could support cross-database
    comparison rules, and why
    """

    supports_referential_integrity_rule_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsReferentialIntegrityRuleWithReason"
    )
    """Indicates whether the table could support referential integrity
    rules, and why
    """

    supports_cardinality_rule_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsCardinalityRuleWithReason"
    )
    """Indicates whether the table could support cardinality rules, and
    why
    """

    supports_data_explorer_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsDataExplorerWithReason"
    )
    """Indicates whether the table could support analysis using the Data
    Explorer, and why
    """

    supports_airflow_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsAirflowWithReason"
    )
    """Indicates whether the table could support Airflow dag
    observability, and why
    """

    supports_dbt_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsDbtWithReason"
    )
    """Indicates whether the table could support dbt observability, and
    why
    """

    supports_databricks_workflow_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsDatabricksWorkflowWithReason"
    )
    """Indicates whether the table could support Databricks Workflowjob
    observability, and why
    """

    supports_fivetran_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsFivetranWithReason"
    )
    """Indicates whether the table could support Fivetran observability,
    and why
    """

    supports_azure_data_factory_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsAzureDataFactoryWithReason"
    )
    """Indicates whether the table could support Azure Data Factory
    pipeline observability, and why
    """

    supports_informatica_with_reason = sgqlc.types.Field(
        TableCapabilitesWithReasonField, graphql_name="supportsInformaticaWithReason"
    )
    """Indicates whether the table could support Informatica
    observability, and why
    """

    has_bytes = sgqlc.types.Field(Boolean, graphql_name="hasBytes")
    """indicates whether the table has byte count metric data points"""

    has_freshness = sgqlc.types.Field(Boolean, graphql_name="hasFreshness")
    """indicates whether the table has freshness metric data points"""

    has_objects_deleted = sgqlc.types.Field(Boolean, graphql_name="hasObjectsDeleted")
    """indicates whether the table has object deleted metric data points"""

    has_rows = sgqlc.types.Field(Boolean, graphql_name="hasRows")
    """indicates whether the table has total row count metric data points"""

    has_total_row_count_change = sgqlc.types.Field(Boolean, graphql_name="hasTotalRowCountChange")
    """indicates whether the table has total row count change metric data
    points
    """

    has_write_throughput = sgqlc.types.Field(Boolean, graphql_name="hasWriteThroughput")
    """indicates whether the table has write throughput metric data
    points
    """

    has_non_metadata_size_collection = sgqlc.types.Field(
        Boolean, graphql_name="hasNonMetadataSizeCollection"
    )
    """indicates whether the table has non-metadata size collection
    enabled
    """


class TableCollectionStatus(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("is_active", "interval_in_seconds", "last_run", "next_run")
    is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive")
    """True if there is a data collection active for this asset"""

    interval_in_seconds = sgqlc.types.Field(Float, graphql_name="intervalInSeconds")
    """Interval in seconds between data collections"""

    last_run = sgqlc.types.Field(DateTime, graphql_name="lastRun")
    """Date & time of last collection run"""

    next_run = sgqlc.types.Field(DateTime, graphql_name="nextRun")
    """Date & time of next collection run"""


class TableColumnsLineageResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "columns_lineage",
        "non_selected_source_columns",
        "timestamp",
        "display_name",
    )
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """Destination(current) table mcon"""

    columns_lineage = sgqlc.types.Field(
        sgqlc.types.list_of(ColumnLineage), graphql_name="columnsLineage"
    )
    """Lineage of the columns in the table"""

    non_selected_source_columns = sgqlc.types.Field(
        sgqlc.types.list_of(LineageSources), graphql_name="nonSelectedSourceColumns"
    )
    """Other columns used in conditions for the current table"""

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")
    """Timestamp when the query that generated the lineage happened"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Display name for BI tables"""


class TableFieldConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TableFieldEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TableFieldDescriptor(sgqlc.types.Type):
    """Information about the table fields"""

    __schema__ = schema
    __field_names__ = ("field_name", "sql_name", "field_type_db", "field_type")
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Display name"""

    sql_name = sgqlc.types.Field(String, graphql_name="sqlName")
    """Field identifier"""

    field_type_db = sgqlc.types.Field(String, graphql_name="fieldTypeDb")
    """Field type as fetched from the warehouse metadata"""

    field_type = sgqlc.types.Field(FieldType, graphql_name="fieldType")
    """Display field type"""


class TableFieldEdge(sgqlc.types.Type):
    """A Relay edge containing a `TableField` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TableField", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableFieldImportance(sgqlc.types.Type):
    """Information about the table fields with an important flag"""

    __schema__ = schema
    __field_names__ = (
        "field_name",
        "is_important",
        "importance_score",
        "field_type_db",
        "field_type",
    )
    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Display name"""

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")

    field_type_db = sgqlc.types.Field(String, graphql_name="fieldTypeDb")
    """Field type as fetched from the warehouse metadata"""

    field_type = sgqlc.types.Field(FieldType, graphql_name="fieldType")
    """Display field type"""


class TableFields(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("table_fields",)
    table_fields = sgqlc.types.Field(
        sgqlc.types.list_of(TableFieldDescriptor), graphql_name="tableFields"
    )


class TableFieldsImportance(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("table_fields",)
    table_fields = sgqlc.types.Field(
        sgqlc.types.list_of(TableFieldImportance), graphql_name="tableFields"
    )


class TableImportanceStatsResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("is_important", "importance_score")
    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")


class TableMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "table_path",
        "is_wildcard",
        "view_query",
        "external_data_sources",
        "created_on",
    )
    table_path = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tablePath")

    is_wildcard = sgqlc.types.Field(Boolean, graphql_name="isWildcard")

    view_query = sgqlc.types.Field(String, graphql_name="viewQuery")

    external_data_sources = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="externalDataSources"
    )

    created_on = sgqlc.types.Field(String, graphql_name="createdOn")


class TableMetadataType(sgqlc.types.Type):
    """Describes the possible widgets that are supported for a given
    table
    """

    __schema__ = schema
    __field_names__ = ("mcon", "supported_widgets")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    supported_widgets = sgqlc.types.Field(
        sgqlc.types.list_of(SupportedWidget), graphql_name="supportedWidgets"
    )


class TableMetricV2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "full_table_id",
        "metric",
        "value",
        "field",
        "timestamp",
        "measurement_timestamp",
        "dimensions",
        "thresholds",
        "job_execution_uuid",
    )
    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")

    field = sgqlc.types.Field(String, graphql_name="field")

    timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp")

    measurement_timestamp = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="measurementTimestamp"
    )

    dimensions = sgqlc.types.Field(MetricDimensions, graphql_name="dimensions")

    thresholds = sgqlc.types.Field(sgqlc.types.list_of("Threshold"), graphql_name="thresholds")
    """Thresholds"""

    job_execution_uuid = sgqlc.types.Field(UUID, graphql_name="jobExecutionUuid")
    """UUID of the job execution that produced the measurement"""


class TableMonitorAlertCondition(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metric", "operator")
    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")

    operator = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="operator")


class TableMonitorConfiguration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "all_records",
        "time_field",
        "aggregation_type",
        "time_field_type",
        "lookback_days",
        "schedule_type",
        "interval_minutes",
        "collection_lag_hours",
        "start_time",
        "low_cardinality_suggestions",
        "bad_cardinality_fields",
        "status",
        "reference_monitor_uuid",
    )
    all_records = sgqlc.types.Field(Boolean, graphql_name="allRecords")
    """Whether to use all records or a time axis"""

    time_field = sgqlc.types.Field(String, graphql_name="timeField")
    """The field to use as the time axis"""

    aggregation_type = sgqlc.types.Field(String, graphql_name="aggregationType")
    """HOUR or DAY"""

    time_field_type = sgqlc.types.Field(String, graphql_name="timeFieldType")
    """Type of time axis field"""

    lookback_days = sgqlc.types.Field(Int, graphql_name="lookbackDays")
    """Number of prior days to create buckets for"""

    schedule_type = sgqlc.types.Field(String, graphql_name="scheduleType")
    """Either Dynamic or Fixed"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Number of minutes between each scheduled run"""

    collection_lag_hours = sgqlc.types.Field(Int, graphql_name="collectionLagHours")
    """Number of minutes between each scheduled run"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """When to schedule the monitor to start (UTC)"""

    low_cardinality_suggestions = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="lowCardinalitySuggestions"
    )
    """Suggested fields for segmentation or DT monitors"""

    bad_cardinality_fields = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="badCardinalityFields"
    )
    """Do not use fields for segmentation or DT monitors"""

    status = sgqlc.types.Field(MonitorConfigurationStatus, graphql_name="status")
    """Status of configuration process"""

    reference_monitor_uuid = sgqlc.types.Field(UUID, graphql_name="referenceMonitorUuid")
    """UUID of the monitor to use as a reference to suggest the default
    configuration. If none, the configuration was instead derived from
    the table characteristics.
    """


class TableMonitorConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TableMonitorEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TableMonitorCoverage(sgqlc.types.Type):
    """Coverage information for a table monitor"""

    __schema__ = schema
    __field_names__ = (
        "tables_at_risk",
        "tables_at_risk_count",
        "non_table_monitors_at_risk",
        "non_table_monitors_at_risk_count",
    )
    tables_at_risk = sgqlc.types.Field(
        "WarehouseTableConnection",
        graphql_name="tablesAtRisk",
        args=sgqlc.types.ArgDict(
            (
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Paginated list of tables that are only covered by this monitor and
    would become unmonitored if this monitor is deleted

    Arguments:

    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tables_at_risk_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="tablesAtRiskCount"
    )
    """Number of tables that will become unmonitored if this monitor is
    deleted (tables only covered by this monitor)
    """

    non_table_monitors_at_risk = sgqlc.types.Field(
        MonitorAtRiskConnection,
        graphql_name="nonTableMonitorsAtRisk",
        args=sgqlc.types.ArgDict(
            (
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Paginated list of monitors that cover tables which are only
    covered by this monitor. These monitors are at risk of covering
    unmonitored tables if this monitor is deleted. Sorted by creation
    date descending.

    Arguments:

    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    non_table_monitors_at_risk_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="nonTableMonitorsAtRiskCount"
    )
    """Number of non-table monitors that cover tables which are only
    covered by this monitor (monitors at risk of covering unmonitored
    tables if this monitor is deleted)
    """


class TableMonitorEdge(sgqlc.types.Type):
    """A Relay edge containing a `TableMonitor` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TableMonitor", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableMonitorMetric(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("metric", "value")
    metric = sgqlc.types.Field(sgqlc.types.non_null(TableMonitorMetricType), graphql_name="metric")

    value = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="value")


class TableMonitorSpec(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "warehouse_uuid",
        "asset_selection",
        "audiences",
        "description",
        "monitor_name",
        "domain_restrictions",
        "alert_conditions",
        "source_notification_rules",
        "source_monitored_table_rules",
        "created_by_id",
        "distinct_mcons_count",
        "notes",
        "uses_monitoring_filters_fallback",
        "ignored_routing_rules",
        "unexpanded_regex_patterns",
    )
    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")

    asset_selection = sgqlc.types.Field(
        sgqlc.types.non_null(AssetSelection), graphql_name="assetSelection"
    )

    audiences = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Audience))),
        graphql_name="audiences",
    )

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")

    monitor_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="monitorName")

    domain_restrictions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainRestrictions"
    )

    alert_conditions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(TableMonitorAlertCondition)),
        graphql_name="alertConditions",
    )

    source_notification_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(RoutingRuleData))),
        graphql_name="sourceNotificationRules",
    )

    source_monitored_table_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitoringRuleData))),
        graphql_name="sourceMonitoredTableRules",
    )

    created_by_id = sgqlc.types.Field(Int, graphql_name="createdById")

    distinct_mcons_count = sgqlc.types.Field(Int, graphql_name="distinctMconsCount")

    notes = sgqlc.types.Field(String, graphql_name="notes")

    uses_monitoring_filters_fallback = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usesMonitoringFiltersFallback"
    )

    ignored_routing_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(RoutingRuleData))),
        graphql_name="ignoredRoutingRules",
    )

    unexpanded_regex_patterns = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("UnexpandedRegexPattern"))),
        graphql_name="unexpandedRegexPatterns",
    )


class TableMonitorStatus(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "full_table_id",
        "time_fields",
        "field_row_counts",
        "cardinality_fields",
        "updated_time",
        "status",
    )
    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    time_fields = sgqlc.types.Field(Boolean, graphql_name="timeFields")
    """Whether time fields have been fetched"""

    field_row_counts = sgqlc.types.Field(Boolean, graphql_name="fieldRowCounts")
    """Whether row counts have been fetched"""

    cardinality_fields = sgqlc.types.Field(Boolean, graphql_name="cardinalityFields")
    """Whether field cardinality has been fetched"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """Last time the table configuration was validated"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Current status of the table"""


class TableMonitorStatuses(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("table_monitor_statuses",)
    table_monitor_statuses = sgqlc.types.Field(
        sgqlc.types.list_of(TableMonitorStatus), graphql_name="tableMonitorStatuses"
    )


class TableOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("mcon", "table_id", "is_key_asset")
    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    table_id = sgqlc.types.Field(String, graphql_name="tableId")

    is_key_asset = sgqlc.types.Field(Boolean, graphql_name="isKeyAsset")


class TablePartitionKeysConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TablePartitionKeysEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TablePartitionKeysEdge(sgqlc.types.Type):
    """A Relay edge containing a `TablePartitionKeys` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TablePartitionKeys", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableRef(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("full_table_id", "table_path")
    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    table_path = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tablePath")


class TableResources(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("table", "view", "external", "wildcard_table")
    table = sgqlc.types.Field(Int, graphql_name="table")

    view = sgqlc.types.Field(Int, graphql_name="view")

    external = sgqlc.types.Field(Int, graphql_name="external")

    wildcard_table = sgqlc.types.Field(Int, graphql_name="wildcardTable")


class TableSchemaVersionConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TableSchemaVersionEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TableSchemaVersionEdge(sgqlc.types.Type):
    """A Relay edge containing a `TableSchemaVersion` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TableSchemaVersion", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableSourceSample(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sources",)
    sources = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="sources")
    """List of unique sources"""


class TableStat(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "resource_uuid",
        "full_table_id",
        "is_important",
        "importance_score",
        "avg_writes_per_active_day",
        "avg_reads_per_active_day",
        "total_users",
        "degree_out",
    )
    resource_uuid = sgqlc.types.Field(UUID, graphql_name="resourceUuid")
    """The warehouse UUID"""

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")
    """Full table identifier"""

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")
    """Indicates whether the table is important"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """The importance score of the table"""

    avg_writes_per_active_day = sgqlc.types.Field(Float, graphql_name="avgWritesPerActiveDay")
    """The average number of writes per active day"""

    avg_reads_per_active_day = sgqlc.types.Field(Float, graphql_name="avgReadsPerActiveDay")
    """The average number of reads per active day"""

    total_users = sgqlc.types.Field(Int, graphql_name="totalUsers")
    """Total number of users"""

    degree_out = sgqlc.types.Field(Int, graphql_name="degreeOut")
    """The degree out"""


class TableStatsConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TableStatsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TableStatsEdge(sgqlc.types.Type):
    """A Relay edge containing a `TableStats` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TableStats", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableStatsV2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("table_stats", "total_count", "page_info")
    table_stats = sgqlc.types.Field(sgqlc.types.list_of(TableStat), graphql_name="tableStats")
    """A list of table stats"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total count of records"""

    page_info = sgqlc.types.Field(PageInfo, graphql_name="pageInfo")
    """Pagination info"""


class TableSummaryStatsType(sgqlc.types.Type):
    """Summary stats for a given table/criteria"""

    __schema__ = schema
    __field_names__ = ("row_count", "row_count_limit", "row_count_limit_exceeded")
    row_count = sgqlc.types.Field(RowCountResponseType, graphql_name="rowCount")
    """Row count response"""

    row_count_limit = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="rowCountLimit")
    """Account-level row count limit"""

    row_count_limit_exceeded = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="rowCountLimitExceeded"
    )
    """Whether account-level row count limit has been exceeded"""


class TableTagConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TableTagEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class TableTagEdge(sgqlc.types.Type):
    """A Relay edge containing a `TableTag` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TableTag", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TableUpstreamData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "upstream_count",
        "upstream_monitored_count",
        "upstream_excluded_count",
        "mcon",
    )
    upstream_count = sgqlc.types.Field(Int, graphql_name="upstreamCount")

    upstream_monitored_count = sgqlc.types.Field(Int, graphql_name="upstreamMonitoredCount")

    upstream_excluded_count = sgqlc.types.Field(Int, graphql_name="upstreamExcludedCount")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")


class TableValidation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "description", "enabled_by_default")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Name of the validation."""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description of the validation."""

    enabled_by_default = sgqlc.types.Field(Boolean, graphql_name="enabledByDefault")
    """Whether this validation will run if no validationNames are
    specified (valid only for asset validations).
    """


class TableauAccount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "data_collector")
    uuid = sgqlc.types.Field(String, graphql_name="uuid")

    data_collector = sgqlc.types.Field(EmptyDataCollector, graphql_name="dataCollector")


class TableauMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("tableau_luid", "tableau_asset_type", "tableau_warning_id")
    tableau_luid = sgqlc.types.Field(String, graphql_name="tableauLuid")
    """Tableau LUID of a Tableau asset"""

    tableau_asset_type = sgqlc.types.Field(String, graphql_name="tableauAssetType")
    """Tableau asset type"""

    tableau_warning_id = sgqlc.types.Field(String, graphql_name="tableauWarningId")
    """Tableau Data Quality Warning ID if there is one"""


class TableauWorkbookCount(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("workbook_count",)
    workbook_count = sgqlc.types.Field(Int, graphql_name="workbookCount")
    """Total number of workbooks in the Tableau instance."""


class TagInfoOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value", "id")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Tag key"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Tag Value"""

    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")
    """Tag ID"""


class TagKeyValuePairOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Tag key"""

    value = sgqlc.types.Field(String, graphql_name="value")
    """Tag Value"""


class TagObjectOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "type",
        "tag_name",
        "tag_value",
        "created_at",
        "updated_at",
        "created_by",
        "updated_by",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of the tag."""

    type = sgqlc.types.Field(sgqlc.types.non_null(TagType), graphql_name="type")
    """Tag type."""

    tag_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tagName")
    """Tag name."""

    tag_value = sgqlc.types.Field(String, graphql_name="tagValue")
    """Tag value."""

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """Tag creation time."""

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")
    """Tag update time."""

    created_by = sgqlc.types.Field(sgqlc.types.non_null("UserInfoOutput"), graphql_name="createdBy")
    """Created by user."""

    updated_by = sgqlc.types.Field(sgqlc.types.non_null("UserInfoOutput"), graphql_name="updatedBy")
    """Updated by user."""


class TaskPerformanceData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("task_summaries",)
    task_summaries = sgqlc.types.Field(
        sgqlc.types.non_null("TaskPerformanceSummaryConnection"),
        graphql_name="taskSummaries",
        args=sgqlc.types.ArgDict(
            (
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Paged list of summary-level information about task performance,
    for tasks that executed in the specified period

    Arguments:

    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class TaskPerformanceSummaryConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("TaskPerformanceSummaryEdge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of tasks matching filter (total count)"""


class TaskPerformanceSummaryEdge(sgqlc.types.Type):
    """A Relay edge containing a `TaskPerformanceSummary` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("TaskPerformanceSummary", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class TestAirflowCredentialsV2(sgqlc.types.Type):
    """Test an Airflow connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        "TestCredentialsV2Response", graphql_name="validationResult"
    )
    """Result of the validation."""


class TestAthenaCredentials(sgqlc.types.Type):
    """Test an Athena connection"""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestAzureDataFactoryCredentials(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Credentials key."""

    validation_result = sgqlc.types.Field(
        "TestCredentialsV2Response", graphql_name="validationResult"
    )
    """Connection validation results."""


class TestAzureDevOpsCredentialsOutput(sgqlc.types.Type):
    """Output type for credential testing."""

    __schema__ = schema
    __field_names__ = ("valid_credentials",)
    valid_credentials = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="validCredentials"
    )


class TestBqCredentials(sgqlc.types.Type):
    """Test a BQ connection"""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestBqCredentialsV2(sgqlc.types.Type):
    """Test a BigQuery connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        "TestCredentialsV2Response", graphql_name="validationResult"
    )
    """Result of the validation."""


class TestConfluentKafkaConnectCredentials(sgqlc.types.Type):
    """Test a confluent Kafka Connect cluster credentials."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connectionThis key is only generated when
    calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        "TestCredentialsV2Response", graphql_name="validationResult"
    )


class TestConfluentKafkaCredentials(sgqlc.types.Type):
    """Test a confluent Kafka cluster credentials."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connectionThis key is only generated when
    calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        "TestCredentialsV2Response", graphql_name="validationResult"
    )


class TestConnectionResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "validations", "warnings")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestCredentialsMutation(sgqlc.types.Type):
    """Test credentials where the temp key already exists (e.g. BQ)"""

    __schema__ = schema
    __field_names__ = ("success", "validations", "warnings")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestCredentialsV2Response(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "success",
        "validation_name",
        "description",
        "errors",
        "warnings",
        "additional_data",
    )
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the validation test was successful."""

    validation_name = sgqlc.types.Field(String, graphql_name="validationName")
    """Name of the validation test that was run."""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description of the validation test that was run."""

    errors = sgqlc.types.Field(sgqlc.types.list_of("ValidationFailure"), graphql_name="errors")
    """List of errors of failed validations."""

    warnings = sgqlc.types.Field(sgqlc.types.list_of("ValidationFailure"), graphql_name="warnings")
    """List of warnings of failed validations."""

    additional_data = sgqlc.types.Field(AdditionalData, graphql_name="additionalData")
    """Optional additional data about the validations that were run."""


class TestDatabaseCredentials(sgqlc.types.Type):
    """Test a generic warehouse or database connection"""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestDatabricksMetastoreSqlWarehouseCredentialsV2(sgqlc.types.Type):
    """Test a Databricks Metastore SQL Warehouse connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestDatabricksSqlWarehouseCredentials(sgqlc.types.Type):
    """Test the connection to a Databricks sql warehouse."""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection."""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully."""


class TestDatabricksSqlWarehouseCredentialsV2(sgqlc.types.Type):
    """Test a Databricks SQL Warehouse connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestDatadogCredentialsOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("valid_credentials",)
    valid_credentials = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="validCredentials"
    )


class TestDbtCloudCredentials(sgqlc.types.Type):
    """Test a dbt Cloud connection"""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestDbtCloudCredentialsV2(sgqlc.types.Type):
    """Test a dbt Cloud connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestFivetranCredentials(sgqlc.types.Type):
    """Test a Fivetran connection"""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestGlueCredentials(sgqlc.types.Type):
    """Test a Glue connection"""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestHiveCredentials(sgqlc.types.Type):
    """Test a hive sql based connection"""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestInformaticaCredentials(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Credentials key."""

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Connection validation results."""


class TestLookerCredentialsV2(sgqlc.types.Type):
    """Test a Looker API connection"""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestLookerGitAuthCredentialsV2(sgqlc.types.Type):
    """Test the connection to a Git repository using the HTTPS or SSH
    protocol
    """

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestLookerGitCloneCredentials(sgqlc.types.Type):
    """Test the connection to a Git repository using the SSH or HTTPS
    protocol
    """

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestLookerGitCloneCredentialsV2(sgqlc.types.Type):
    """Test the connection to a Git repository using the HTTPS protocol"""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestLookerGitCredentials(sgqlc.types.Type):
    """Deprecated. Do not use."""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestMskKafkaConnectCredentials(sgqlc.types.Type):
    """Test MSK Kafka Connect credentials."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connectionThis key is only generated when
    calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )


class TestMskKafkaCredentials(sgqlc.types.Type):
    """Test MSK Kafka cluster credentials."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connectionThis key is only generated when
    calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )


class TestPineconeCredentials(sgqlc.types.Type):
    """Test a Pinecone connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Credentials key."""

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Connection validation results."""


class TestPowerBICredentials(sgqlc.types.Type):
    """Test the Power BI connection"""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestPowerBICredentialsV2(sgqlc.types.Type):
    """Test a PowerBI connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestPrestoCredentials(sgqlc.types.Type):
    """Test connection to Presto"""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestRedshiftCredentialsV2(sgqlc.types.Type):
    """Test a Redshift connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestS3Credentials(sgqlc.types.Type):
    """Test a s3 based connection (e.g. presto query logs on s3)"""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestSelfHostedCredentials(sgqlc.types.Type):
    """Test a connection of any type with self-hosted credentials."""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestSelfHostedCredentialsV2(sgqlc.types.Type):
    """Test self-hosted credentials for a new connection of the specified
    type.
    """

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestSelfHostedKafkaConnectCredentials(sgqlc.types.Type):
    """Test a Self Hosted Kafka Connect cluster credentials."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connectionThis key is only generated when
    calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )


class TestSelfHostedKafkaCredentials(sgqlc.types.Type):
    """Test Self Hosted Kafka cluster credentials."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connectionThis key is only generated when
    calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )


class TestSnowflakeCredentials(sgqlc.types.Type):
    """Test a Snowflake connection"""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestSnowflakeCredentialsV2(sgqlc.types.Type):
    """Test a Snowflake connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection.This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestSparkCredentials(sgqlc.types.Type):
    """Test the connection to a Spark Thrift server."""

    __schema__ = schema
    __field_names__ = ("key", "success")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class TestTableauCredentialsMutation(sgqlc.types.Type):
    """Test a tableau account before adding"""

    __schema__ = schema
    __field_names__ = ("key", "success", "validations", "warnings")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validations = sgqlc.types.Field(
        sgqlc.types.list_of(ConnectionValidation), graphql_name="validations"
    )
    """List of validations that passed"""

    warnings = sgqlc.types.Field(sgqlc.types.list_of(ConnectionValidation), graphql_name="warnings")
    """List of warnings of failed validations"""


class TestTableauCredentialsV2(sgqlc.types.Type):
    """Test a Tableau connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection. This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestTransactionalDbCredentialsV2(sgqlc.types.Type):
    """Test a Transactional DB connection."""

    __schema__ = schema
    __field_names__ = ("key", "validation_result")
    key = sgqlc.types.Field(String, graphql_name="key")
    """Path to key for adding a connection.This key is only generated
    when calling the SAVE_CREDENTIALS validation.
    """

    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class TestUpdatedCredentialsV2Mutation(sgqlc.types.Type):
    """Test the updated credentials of an existing connection."""

    __schema__ = schema
    __field_names__ = ("validation_result",)
    validation_result = sgqlc.types.Field(
        TestCredentialsV2Response, graphql_name="validationResult"
    )
    """Result of the validation."""


class Threshold(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "type",
        "upper",
        "lower",
        "reason",
        "status",
        "upper_high",
        "lower_high",
        "upper_medium",
        "lower_medium",
        "upper_low",
        "lower_low",
    )
    type = sgqlc.types.Field(sgqlc.types.non_null(ThresholdType), graphql_name="type")
    """Threshold type"""

    upper = sgqlc.types.Field(Float, graphql_name="upper")
    """Upper threshold"""

    lower = sgqlc.types.Field(Float, graphql_name="lower")
    """Lower threshold"""

    reason = sgqlc.types.Field(String, graphql_name="reason")
    """Reason for missing threshold"""

    status = sgqlc.types.Field(sgqlc.types.non_null(ThresholdStatus), graphql_name="status")
    """Threshold status"""

    upper_high = sgqlc.types.Field(Float, graphql_name="upperHigh")
    """Upper High-Sensitivity threshold"""

    lower_high = sgqlc.types.Field(Float, graphql_name="lowerHigh")
    """Lower High-Sensitivity threshold"""

    upper_medium = sgqlc.types.Field(Float, graphql_name="upperMedium")
    """Upper Medium-Sensitivity threshold"""

    lower_medium = sgqlc.types.Field(Float, graphql_name="lowerMedium")
    """Lower Medium-Sensitivity threshold"""

    upper_low = sgqlc.types.Field(Float, graphql_name="upperLow")
    """Upper Low-Sensitivity threshold"""

    lower_low = sgqlc.types.Field(Float, graphql_name="lowerLow")
    """Lower Low-Sensitivity threshold"""


class ThresholdLMHType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("low", "medium", "high")
    low = sgqlc.types.Field(Float, graphql_name="low")
    """Lower threshold"""

    medium = sgqlc.types.Field(Float, graphql_name="medium")
    """Medium threshold"""

    high = sgqlc.types.Field(Float, graphql_name="high")
    """High threshold"""


class ThresholdModifier(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("modifier_type", "value")
    modifier_type = sgqlc.types.Field(
        sgqlc.types.non_null(ThresholdModifierType), graphql_name="modifierType"
    )
    """The type of threshold modifier"""

    value = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="value")
    """The value of the threshold modifier. If the type is PERCENTAGE,
    this should be a decimal value.
    """


class ThresholdsData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("freshness", "size", "field_health", "dynamic")
    freshness = sgqlc.types.Field(Freshness, graphql_name="freshness")
    """Freshness anomaly threshold"""

    size = sgqlc.types.Field(Size, graphql_name="size")
    """Size anomaly threshold"""

    field_health = sgqlc.types.Field(
        FieldHealth,
        graphql_name="fieldHealth",
        args=sgqlc.types.ArgDict(
            (
                ("monitor", sgqlc.types.Arg(String, graphql_name="monitor", default=None)),
                ("field", sgqlc.types.Arg(String, graphql_name="field", default=None)),
                ("metric", sgqlc.types.Arg(String, graphql_name="metric", default=None)),
                (
                    "where_condition",
                    sgqlc.types.Arg(String, graphql_name="whereCondition", default=None),
                ),
            )
        ),
    )
    """Deprecated: Field health anomaly thresholds

    Arguments:

    * `monitor` (`String`)None
    * `field` (`String`)None
    * `metric` (`String`)None
    * `where_condition` (`String`)None
    """

    dynamic = sgqlc.types.Field(
        Dynamic,
        graphql_name="dynamic",
        args=sgqlc.types.ArgDict(
            (("rule", sgqlc.types.Arg(String, graphql_name="rule", default=None)),)
        ),
    )
    """Arguments:

    * `rule` (`String`)None
    """


class TimeAxisDeltaDetectionResult(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("delta",)
    delta = sgqlc.types.Field(Int, graphql_name="delta")
    """time delta between the time axis and intrinsic time"""


class TimeAxisMetadata(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("candidates", "suggested")
    candidates = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="candidates")
    """Fields which can be used as time axis"""

    suggested = sgqlc.types.Field(String, graphql_name="suggested")
    """Field most likely to be the time axis"""


class TimeRangeOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "look_back_length",
        "look_back_unit",
        "metric_group_period_unit",
        "start_time",
        "end_time",
    )
    look_back_length = sgqlc.types.Field(Int, graphql_name="lookBackLength")
    """Looking back range."""

    look_back_unit = sgqlc.types.Field(TimeRangeUnit, graphql_name="lookBackUnit")
    """Look back unit. Valid options: [DAY, WEEK, MONTH]"""

    metric_group_period_unit = sgqlc.types.Field(String, graphql_name="metricGroupPeriodUnit")
    """Metrics grouping unit. Valid options: [DAY, WEEK, MONTH]"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start Time of the dashboard time range."""

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")
    """End Time of the dashboard time range."""


class TimeSeries(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("group_value", "data")
    group_value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="groupValue")

    data = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(DataPoint)), graphql_name="data"
    )


class TimelineEventData(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("timeline_events",)
    timeline_events = sgqlc.types.Field(
        sgqlc.types.list_of("TimeLineEvent"), graphql_name="timelineEvents"
    )


class ToggleAccountFeature(sgqlc.types.Type):
    """Enable/disable an account level feature"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the feature was enabled or disabled successfully"""


class ToggleAlertGrouping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Warehouse incident grouping status."""


class ToggleConnectionEnable(sgqlc.types.Type):
    """Enable or Disable a connection. This will also skip/un-skip all
    related data collector schedules.
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the connection was enabled or disabled
    successfully
    """


class ToggleCreateAlertsInDatasource(sgqlc.types.Type):
    """Enable/disable the creation of alerts in the warehouse (when
    supported)
    """

    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")


class ToggleDataProductMonitoring(sgqlc.types.Type):
    """Enables/disables automatic monitoring on a data product"""

    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """Automatic monitoring is enabled or disabled"""


class ToggleDisableSampling(sgqlc.types.Type):
    """Enable/disable the sampling data feature"""

    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")


class ToggleDisableValueIngestion(sgqlc.types.Type):
    """Enable/disable the value ingestion feature"""

    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")


class ToggleDisableValueSamplingWhenTesting(sgqlc.types.Type):
    """Enable/disable the sampling data feature when testing value-based
    sql rules
    """

    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")


class ToggleEventConfig(sgqlc.types.Type):
    """Enable / disable the configuration for data collection via events"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class ToggleFullDistributionMetrics(sgqlc.types.Type):
    """DEPRECATED"""

    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")


class ToggleIncidentGrouping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Warehouse incident grouping status."""


class ToggleMuteDatasetPayload(sgqlc.types.Type):
    """(Deprecated) Start/Stop creating incidents for the given dataset"""

    __schema__ = schema
    __field_names__ = ("muted", "client_mutation_id")
    muted = sgqlc.types.Field("Dataset", graphql_name="muted")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteDatasetsPayload(sgqlc.types.Type):
    """(Deprecated) Start/Stop creating incidents for the given datasets"""

    __schema__ = schema
    __field_names__ = ("muted", "client_mutation_id")
    muted = sgqlc.types.Field(sgqlc.types.list_of("Dataset"), graphql_name="muted")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteTablePayload(sgqlc.types.Type):
    """(Deprecated) Start/Stop creating incidents for the given table"""

    __schema__ = schema
    __field_names__ = ("muted", "client_mutation_id")
    muted = sgqlc.types.Field("WarehouseTable", graphql_name="muted")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteTablesPayload(sgqlc.types.Type):
    """(Deprecated) Start/Stop creating incidents for the given tables"""

    __schema__ = schema
    __field_names__ = ("muted", "client_mutation_id")
    muted = sgqlc.types.Field(sgqlc.types.list_of("WarehouseTable"), graphql_name="muted")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class ToggleMuteWithRegexPayload(sgqlc.types.Type):
    """(Deprecated) Start/Stop creating incidents for all matched
    elements. Use wildcards to match more than one table or dataset.
    """

    __schema__ = schema
    __field_names__ = ("client_mutation_id",)
    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class TogglePerformanceDashboardForDomainRestrictedUsers(sgqlc.types.Type):
    """Sets the toggle for enabling performance dashboard for domain
    restricted users
    """

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class ToggleRestrictSampling(sgqlc.types.Type):
    """Enable/disable to restrict certain roles to access sampling data"""

    __schema__ = schema
    __field_names__ = ("enable",)
    enable = sgqlc.types.Field(Boolean, graphql_name="enable")


class ToggleSchemaChangeAlertGrouping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Warehouse schema change grouping status."""


class ToggleSchemaChangeIncidentGrouping(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("disabled",)
    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Warehouse schema change grouping status."""


class ToggleSizeCollection(sgqlc.types.Type):
    """Toggle Size Collection for an assets which doesn't support
    metadata
    """

    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")


class ToggleSlackBroadcastUpdates(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """The resulting enabled/disabled state for the feature"""


class ToggleSlackReplyWarning(sgqlc.types.Type):
    """Enable/disable the Slack reply warning feature"""

    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")
    """The resulting enabled/disabled state for the feature"""


class ToggleWarehouseTagsCollectionSetting(sgqlc.types.Type):
    """Enable or disable the tags collection for the warehouse"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""


class ToggleWildcardAggregation(sgqlc.types.Type):
    """Enables/disable aggregation of wildcard tables (defaults to yearly
    and monthly templates)
    """

    __schema__ = schema
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")


class TokenMetadata(sgqlc.types.Type):
    """Metadata for the API Access Token"""

    __schema__ = schema
    __field_names__ = (
        "id",
        "first_name",
        "last_name",
        "email",
        "creation_time",
        "created_by",
        "expiration_time",
        "comment",
        "is_service_api_token",
        "groups",
    )
    id = sgqlc.types.Field(String, graphql_name="id")
    """Token id"""

    first_name = sgqlc.types.Field(String, graphql_name="firstName")
    """First name for the owner of the token"""

    last_name = sgqlc.types.Field(String, graphql_name="lastName")
    """Last name for the owner of the token"""

    email = sgqlc.types.Field(String, graphql_name="email")
    """Email for the owner of the token"""

    creation_time = sgqlc.types.Field(DateTime, graphql_name="creationTime")
    """When the token was created"""

    created_by = sgqlc.types.Field(String, graphql_name="createdBy")
    """Who created the token"""

    expiration_time = sgqlc.types.Field(DateTime, graphql_name="expirationTime")
    """When the token is set to expire"""

    comment = sgqlc.types.Field(String, graphql_name="comment")
    """Any comments or description for the token"""

    is_service_api_token = sgqlc.types.Field(Boolean, graphql_name="isServiceApiToken")
    """True if this is an account service token; false if it's a personal
    token
    """

    groups = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="groups")
    """Names of the groups for the API token (for service API tokens)."""


class TopQueryGroupsResponseType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total", "top_query_groups")
    total = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="total")

    top_query_groups = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(QueryGroupSummaryType)),
        graphql_name="topQueryGroups",
    )


class Trace(sgqlc.types.Type):
    """Traces from the agent_spans table."""

    __schema__ = schema
    __field_names__ = (
        "agent_uuid",
        "agent_name",
        "trace_id",
        "trace_start_time",
        "trace_end_time",
        "ingest_start_time",
        "ingest_end_time",
        "duration_seconds",
        "prompt_tokens",
        "completion_tokens",
        "total_tokens",
        "count_llm_calls",
        "models",
        "workflows",
        "tasks",
    )
    agent_uuid = sgqlc.types.Field(UUID, graphql_name="agentUuid")
    """Agent UUID (nullable for now, will be required in the future)"""

    agent_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="agentName")
    """Agent name"""

    trace_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="traceId")
    """Trace ID (hex-encoded)"""

    trace_start_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="traceStartTime"
    )
    """Earliest span start time in trace"""

    trace_end_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="traceEndTime")
    """Latest span end time in trace"""

    ingest_start_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="ingestStartTime"
    )
    """Earliest span ingest time in trace"""

    ingest_end_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="ingestEndTime"
    )
    """Latest span ingest time in trace"""

    duration_seconds = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="durationSeconds"
    )
    """Trace duration in seconds"""

    prompt_tokens = sgqlc.types.Field(Int, graphql_name="promptTokens")
    """Total prompt tokens"""

    completion_tokens = sgqlc.types.Field(Int, graphql_name="completionTokens")
    """Total completion tokens"""

    total_tokens = sgqlc.types.Field(Int, graphql_name="totalTokens")
    """Total tokens"""

    count_llm_calls = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="countLlmCalls")
    """Number of LLM calls in trace"""

    models = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="models",
    )
    """Unique models used in trace"""

    workflows = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="workflows",
    )
    """Unique workflows in trace"""

    tasks = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="tasks",
    )
    """Unique tasks in trace"""


class TraceConnection(sgqlc.types.relay.Connection):
    """Connection type for trace pagination."""

    __schema__ = schema
    __field_names__ = ("edges", "page_info")
    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TraceEdge"))),
        graphql_name="edges",
    )
    """List of edges"""

    page_info = sgqlc.types.Field(sgqlc.types.non_null("TracePageInfo"), graphql_name="pageInfo")
    """Pagination information"""


class TraceEdge(sgqlc.types.Type):
    """Edge type for trace pagination."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field(sgqlc.types.non_null(Trace), graphql_name="node")
    """The trace"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """Cursor for this edge"""


class TraceFilter(sgqlc.types.Type):
    """Metadata about a trace filter."""

    __schema__ = schema
    __field_names__ = (
        "field_name",
        "display_name",
        "query_parameter_name",
        "query_parameter_accepts_multiple_values",
        "is_range_filter",
        "facetable",
        "facet_searchable",
    )
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(TraceFilterFieldName), graphql_name="fieldName"
    )

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")

    query_parameter_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="queryParameterName"
    )
    """Associated getTraces parameter used to filter traces"""

    query_parameter_accepts_multiple_values = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="queryParameterAcceptsMultipleValues"
    )
    """Whether the associated getTraces parameter accepts multiple values
    as input
    """

    is_range_filter = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isRangeFilter")
    """Whether this is a range filter (min/max) vs equality filter
    (checkboxes)
    """

    facetable = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="facetable")
    """Whether the filter shows up as a facet in the UI"""

    facet_searchable = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="facetSearchable"
    )
    """Whether the filter values can be searched by their display name"""


class TraceFilterData(sgqlc.types.Type):
    """Filter values with counts for a single filter."""

    __schema__ = schema
    __field_names__ = ("field_name", "values", "page_info")
    field_name = sgqlc.types.Field(
        sgqlc.types.non_null(TraceFilterFieldName), graphql_name="fieldName"
    )
    """The filter field name"""

    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TraceFilterDataValue"))),
        graphql_name="values",
    )
    """List of filter values with counts"""

    page_info = sgqlc.types.Field(
        sgqlc.types.non_null("TraceFilterDataPageInfo"), graphql_name="pageInfo"
    )
    """Pagination information"""


class TraceFilterDataPageInfo(sgqlc.types.Type):
    """Pagination info for filter values."""

    __schema__ = schema
    __field_names__ = ("has_next_page", "end_cursor")
    has_next_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasNextPage")
    """Whether there are more results"""

    end_cursor = sgqlc.types.Field(String, graphql_name="endCursor")
    """Cursor for the next page"""


class TraceFilterDataValue(sgqlc.types.Type):
    """A single filter value with its count."""

    __schema__ = schema
    __field_names__ = ("value", "display_name", "count")
    value = sgqlc.types.Field(sgqlc.types.non_null(GenericScalar), graphql_name="value")
    """The filter value"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """Display name for the value"""

    count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="count")
    """Number of traces with this value"""


class TraceNode(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "node_name",
        "span_id",
        "trace_id",
        "parent_span_id",
        "duration",
        "start_time",
        "end_time",
        "ingest_time",
        "has_prompts",
        "has_completions",
        "prompt_tokens",
        "completion_tokens",
        "total_tokens",
        "model",
        "agent_name",
        "workflow",
        "task",
        "child_span_ids",
        "start_extra_ns",
        "end_extra_ns",
    )
    node_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="nodeName")

    span_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="spanId")

    trace_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="traceId")

    parent_span_id = sgqlc.types.Field(String, graphql_name="parentSpanId")

    duration = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="duration")

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")

    ingest_time = sgqlc.types.Field(DateTime, graphql_name="ingestTime")

    has_prompts = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasPrompts")

    has_completions = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasCompletions"
    )

    prompt_tokens = sgqlc.types.Field(Int, graphql_name="promptTokens")

    completion_tokens = sgqlc.types.Field(Int, graphql_name="completionTokens")

    total_tokens = sgqlc.types.Field(Int, graphql_name="totalTokens")

    model = sgqlc.types.Field(String, graphql_name="model")

    agent_name = sgqlc.types.Field(String, graphql_name="agentName")

    workflow = sgqlc.types.Field(String, graphql_name="workflow")

    task = sgqlc.types.Field(String, graphql_name="task")

    child_span_ids = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="childSpanIds",
    )

    start_extra_ns = sgqlc.types.Field(Int, graphql_name="startExtraNs")

    end_extra_ns = sgqlc.types.Field(Int, graphql_name="endExtraNs")


class TracePageInfo(sgqlc.types.Type):
    """PageInfo for trace pagination (Relay spec compliant)."""

    __schema__ = schema
    __field_names__ = (
        "has_next_page",
        "has_previous_page",
        "start_cursor",
        "end_cursor",
        "total_count",
    )
    has_next_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasNextPage")
    """Whether there are more results after this page"""

    has_previous_page = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="hasPreviousPage"
    )
    """Whether there are more results before this page"""

    start_cursor = sgqlc.types.Field(String, graphql_name="startCursor")
    """Cursor of the first edge"""

    end_cursor = sgqlc.types.Field(String, graphql_name="endCursor")
    """Cursor of the last edge"""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total number of results"""


class TrackTablePayload(sgqlc.types.Type):
    """Add table to account's dashboard"""

    __schema__ = schema
    __field_names__ = ("table", "client_mutation_id")
    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class Transform(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "alias",
        "prompt",
        "categories",
        "model_connection_id",
        "output_type",
        "sql_expression",
        "field_config_list",
        "model_name",
        "function",
        "field",
        "id",
    )
    alias = sgqlc.types.Field(String, graphql_name="alias")

    prompt = sgqlc.types.Field(String, graphql_name="prompt")

    categories = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ClassificationCategories)),
        graphql_name="categories",
    )

    model_connection_id = sgqlc.types.Field(String, graphql_name="modelConnectionId")

    output_type = sgqlc.types.Field(String, graphql_name="outputType")

    sql_expression = sgqlc.types.Field(String, graphql_name="sqlExpression")

    field_config_list = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(FieldConfig)), graphql_name="fieldConfigList"
    )

    model_name = sgqlc.types.Field(String, graphql_name="modelName")

    function = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="function")

    field = sgqlc.types.Field(String, graphql_name="field")

    id = sgqlc.types.Field(String, graphql_name="id")


class TransformFunction(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "name",
        "title",
        "description",
        "sql",
        "supported_types",
        "required_type",
        "supported_connections",
        "category",
        "prompt",
        "score_field",
        "output_type",
        "output_description",
        "supports_field_range",
        "supported_output_types",
        "icon",
        "sql_expression",
    )
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title")

    description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description")

    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")

    supported_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FieldType))),
        graphql_name="supportedTypes",
    )

    required_type = sgqlc.types.Field(
        sgqlc.types.non_null(PredicateRequiredType), graphql_name="requiredType"
    )

    supported_connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="supportedConnections",
    )

    category = sgqlc.types.Field(String, graphql_name="category")

    prompt = sgqlc.types.Field(String, graphql_name="prompt")

    score_field = sgqlc.types.Field(String, graphql_name="scoreField")

    output_type = sgqlc.types.Field(String, graphql_name="outputType")

    output_description = sgqlc.types.Field(String, graphql_name="outputDescription")

    supports_field_range = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsFieldRange"
    )

    supported_output_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="supportedOutputTypes",
    )

    icon = sgqlc.types.Field(String, graphql_name="icon")

    sql_expression = sgqlc.types.Field(String, graphql_name="sqlExpression")


class TriggerCircuitBreakerRule(sgqlc.types.Type):
    """Run a custom rule as a circuit breaker immediately. Supports rules
    that create a single query.
    """

    __schema__ = schema
    __field_names__ = ("job_execution_uuid",)
    job_execution_uuid = sgqlc.types.Field(UUID, graphql_name="jobExecutionUuid")


class TriggerCircuitBreakerRuleV2(sgqlc.types.Type):
    """Run a custom rule as a circuit breaker immediately. Supports rules
    that create multiple queries.
    """

    __schema__ = schema
    __field_names__ = ("job_execution_uuids",)
    job_execution_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(UUID), graphql_name="jobExecutionUuids"
    )
    """The UUIDs of the triggered rule job executions."""


class TriggerCustomRule(sgqlc.types.Type):
    """Run a custom rule immediately"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class TriggerMigrationTest(sgqlc.types.Type):
    """Triggers the DC migration test operation that checks if all
    connections in DC can be migrated to target_dc. Validations are
    executed in background, you can check the progress using
    getMigrationTestStatus.
    """

    __schema__ = schema
    __field_names__ = ("migration_uuid",)
    migration_uuid = sgqlc.types.Field(UUID, graphql_name="migrationUuid")
    """UUID assigned to the operation, used to check status"""


class TriggerPlatformMigration(sgqlc.types.Type):
    """Triggers the platform migration for a given DC in background,
    dryRun can be used to run validations without performing the
    migration.
    """

    __schema__ = schema
    __field_names__ = ("migration_uuid",)
    migration_uuid = sgqlc.types.Field(UUID, graphql_name="migrationUuid")
    """UUID assigned to the operation, used to check status"""


class TriggerPlatformMigrationTest(sgqlc.types.Type):
    """Triggers a platform migration test for a given DC in background,
    use getPlatformMigrationTestStatus to get results.
    """

    __schema__ = schema
    __field_names__ = ("migration_uuid",)
    migration_uuid = sgqlc.types.Field(UUID, graphql_name="migrationUuid")
    """UUID assigned to the operation, used to check status"""


class UCSAutomatedAlertConditionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sensitivity_level",)
    sensitivity_level = sgqlc.types.Field(
        sgqlc.types.non_null(SensitivityLevels), graphql_name="sensitivityLevel"
    )
    """Sensitivity for automated thresholds"""


class UCSDetectorThresholdOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value",)
    value = sgqlc.types.Field(sgqlc.types.non_null(ThresholdLMHType), graphql_name="value")
    """Thresholds in minutes"""


class UCSExplicitAlertConditionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "start_time",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "timezone",
        "is_auto_schedule_config",
        "threshold",
    )
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of the collection"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Collection interval in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Collection interval in crontab format"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions"""

    is_auto_schedule_config = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isAutoScheduleConfig"
    )
    """True if auto schedule configuration is used"""

    threshold = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="threshold")
    """Explicit freshness threshold in minutes"""


class UCSTableMonitorConfigOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "status",
        "metric",
        "most_recent_value",
        "collection_status",
        "supports_explicit_alert_condition",
        "tags",
        "data_quality_dimension",
        "alert_condition",
        "detector_threshold",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""

    status = sgqlc.types.Field(
        sgqlc.types.non_null(ConsolidatedMonitorStatusType), graphql_name="status"
    )
    """Detection status"""

    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")
    """Name of metric for which the detector is active"""

    most_recent_value = sgqlc.types.Field(Float, graphql_name="mostRecentValue")
    """Most recent value change analyzed by the detector"""

    collection_status = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionStatusOutput), graphql_name="collectionStatus"
    )
    """Collection status information"""

    supports_explicit_alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsExplicitAlertCondition"
    )
    """True if using the explicit alert condition is supported"""

    tags = sgqlc.types.Field(sgqlc.types.list_of(TagKeyValuePairOutput), graphql_name="tags")
    """Tags for the alert condition"""

    data_quality_dimension = sgqlc.types.Field(String, graphql_name="dataQualityDimension")
    """Data quality dimension for the alert condition"""

    alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null("UCSAlertConditionOutput"), graphql_name="alertCondition"
    )
    """Alert condition configuration"""

    detector_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(UCSDetectorThresholdOutput), graphql_name="detectorThreshold"
    )
    """Detector freshness threshold"""


class UnexpandedRegexPattern(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "original_regex",
        "converted_wildcard",
        "is_exclude",
        "rule_id",
        "warehouse_uuid",
    )
    original_regex = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="originalRegex")

    converted_wildcard = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="convertedWildcard"
    )

    is_exclude = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExclude")

    rule_id = sgqlc.types.Field(Int, graphql_name="ruleId")

    warehouse_uuid = sgqlc.types.Field(String, graphql_name="warehouseUuid")


class UnifiedUserAssignmentConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UnifiedUserAssignmentEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class UnifiedUserAssignmentEdge(sgqlc.types.Type):
    """A Relay edge containing a `UnifiedUserAssignment` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UnifiedUserAssignment", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UnifiedUserConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UnifiedUserEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class UnifiedUserEdge(sgqlc.types.Type):
    """A Relay edge containing a `UnifiedUser` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UnifiedUser", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UnknownVectorIndexMetadata(sgqlc.types.Type):
    """Default metadata for unknown vector database"""

    __schema__ = schema
    __field_names__ = ("vector_db",)
    vector_db = sgqlc.types.Field(String, graphql_name="vectorDb")


class UnlinkAzureDevOpsWorkItemForAlert(sgqlc.types.Type):
    """Unlink an Azure DevOps work item from a Monte Carlo alert.  This
    mutation removes the link between a work item and an alert. The
    work item itself is not deleted in Azure DevOps.
    """

    __schema__ = schema
    __field_names__ = ("unlinked",)
    unlinked = sgqlc.types.Field(Boolean, graphql_name="unlinked")
    """True if the work item was unlinked"""


class UnlinkDatadogIncidentForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("unlinked",)
    unlinked = sgqlc.types.Field(Boolean, graphql_name="unlinked")
    """True if the incident was unlinked"""


class UnlinkJiraTicketForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("unlinked",)
    unlinked = sgqlc.types.Field(Boolean, graphql_name="unlinked")
    """True if the ticket was unlinked"""


class UnlinkJiraTicketForIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("unlinked",)
    unlinked = sgqlc.types.Field(Boolean, graphql_name="unlinked")
    """True if the ticket was unlinked"""


class UnlinkOpsgenieIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("deleted",)
    deleted = sgqlc.types.Field(Boolean, graphql_name="deleted")
    """If the incident was deleted"""


class UnlinkServiceNowIncidentForAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("unlinked",)
    unlinked = sgqlc.types.Field(Boolean, graphql_name="unlinked")
    """True if the incident was unlinked"""


class UnsnoozeCustomRule(sgqlc.types.Type):
    """Un-snooze a custom rule."""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class UnsnoozeCustomRules(sgqlc.types.Type):
    """Un-snooze a list of custom rules."""

    __schema__ = schema
    __field_names__ = ("custom_rules",)
    custom_rules = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("CustomRule")), graphql_name="customRules"
    )


class UnsnoozeDbtNode(sgqlc.types.Type):
    """Un-snooze a DBT node (model/test)."""

    __schema__ = schema
    __field_names__ = ("node",)
    node = sgqlc.types.Field("DbtNode", graphql_name="node")


class UpdateAccountDisplayCatalogSearchTags(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("account",)
    account = sgqlc.types.Field(Account, graphql_name="account")


class UpdateAccountSecret(sgqlc.types.Type):
    """Update an account secret"""

    __schema__ = schema
    __field_names__ = ("secret",)
    secret = sgqlc.types.Field(AccountSecretOutput, graphql_name="secret")
    """The secret that was updated"""


class UpdateAgentParameters(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("update_result",)
    update_result = sgqlc.types.Field(GenericScalar, graphql_name="updateResult")
    """The result object returned from the agent."""


class UpdateAlert(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("alert",)
    alert = sgqlc.types.Field("Alert", graphql_name="alert")
    """The updated alert"""


class UpdateAzureDataFactoryCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Azure Data Factory connection.
    Note: This mutation only uploads credentials and returns a
    temporary key. To complete the update:  Call
    testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field("UpdateCredentialsV2Result", graphql_name="result")


class UpdateAzureDevOpsIntegration(sgqlc.types.Type):
    """Update an existing Azure DevOps integration."""

    __schema__ = schema
    __field_names__ = ("azure_devops_integration", "oauth_redirect_url")
    azure_devops_integration = sgqlc.types.Field(
        AzureDevOpsIntegrationOutput, graphql_name="azureDevopsIntegration"
    )
    """The updated integration"""

    oauth_redirect_url = sgqlc.types.Field(String, graphql_name="oauthRedirectUrl")
    """OAuth redirect URL if OAuth credentials were provided"""


class UpdateAzureDevopsInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("installation", "oauth_redirect_url")
    installation = sgqlc.types.Field(AzureDevopsInstallation, graphql_name="installation")
    """Updated Azure DevOps installation"""

    oauth_redirect_url = sgqlc.types.Field(String, graphql_name="oauthRedirectUrl")


class UpdateBiConnectionNameMutation(sgqlc.types.Type):
    """Update the name of an existing BI integration."""

    __schema__ = schema
    __field_names__ = ("bi_container",)
    bi_container = sgqlc.types.Field(BiContainer, graphql_name="biContainer")


class UpdateBigQueryCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Big Query connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field("UpdateCredentialsV2Result", graphql_name="result")


class UpdateCredentials(sgqlc.types.Type):
    """Update credentials for a connection"""

    __schema__ = schema
    __field_names__ = ("success", "updated_at")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """If the credentials were successfully updated"""

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")
    """The timestamp when the credentials were last updated"""


class UpdateCredentialsV2Mutation(sgqlc.types.Type):
    """Save the updated credentials for an existing connection."""

    __schema__ = schema
    __field_names__ = ("success", "updated_at")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Result of the update credentials operation."""

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")
    """The timestamp when the credentials were last updated"""


class UpdateCredentialsV2Result(sgqlc.types.Type):
    """Result of UpdateCredentialsV2 operation."""

    __schema__ = schema
    __field_names__ = ("success", "key")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """If the operation was successful."""

    key = sgqlc.types.Field(String, graphql_name="key")
    """Temporary credentials key to be used to persist these credentials
    if desired.
    """


class UpdateCustomMetricRuleNotes(sgqlc.types.Type):
    """Create or update notes for custom metric rule"""

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class UpdateCustomMetricSeverity(sgqlc.types.Type):
    """DEPRECATED. Create or update default severity for custom metric
    rule
    """

    __schema__ = schema
    __field_names__ = ("custom_rule",)
    custom_rule = sgqlc.types.Field("CustomRule", graphql_name="customRule")


class UpdateCustomRuleInvestigationQuery(sgqlc.types.Type):
    """Update a rule's investigation query"""

    __schema__ = schema
    __field_names__ = ("rule",)
    rule = sgqlc.types.Field("CustomRule", graphql_name="rule")
    """The updated rule"""


class UpdateDailyUsageAlertConfig(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class UpdateDataProductSharing(sgqlc.types.Type):
    """Create or update sharing definition on a data product"""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Status of the sharing operation."""


class UpdateDataShare(sgqlc.types.Type):
    """Update data sharing configuration for an account. This allows
    Customer Success team to enable/disable data sharing without
    requiring data engineering intervention.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field("UpdateDataShareOutput", graphql_name="result")
    """Result of the data share update operation"""


class UpdateDataShareOutput(sgqlc.types.Type):
    """Result of updating data share configuration"""

    __schema__ = schema
    __field_names__ = ("success", "data_share", "message")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the operation was successful"""

    data_share = sgqlc.types.Field(DataShareOutput, graphql_name="dataShare")
    """Updated data share configuration (null if disabled)"""

    message = sgqlc.types.Field(String, graphql_name="message")
    """Success or error message"""


class UpdateDatabricksMetastoreSQLWarehouseCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Databricks Metastore SQL
    Warehouse connection.  Note: This mutation only uploads
    credentials and returns a temporary key. To complete the update:
    Call testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateDatabricksSQLWarehouseCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Databricks SQL Warehouse
    connection.  Note: This mutation only uploads credentials and
    returns a temporary key. To complete the update:  Call
    testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateDatadogIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("datadog_integration",)
    datadog_integration = sgqlc.types.Field(
        DatadogIntegrationOutput, graphql_name="datadogIntegration"
    )
    """The integration"""


class UpdateDbtCloudCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing dbt cloud connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateDbtProjectInfo(sgqlc.types.Type):
    """Set extra information about dbt project"""

    __schema__ = schema
    __field_names__ = ("project",)
    project = sgqlc.types.Field("DbtProject", graphql_name="project")
    """dbt project after the update"""


class UpdateGithubAppInstallation(sgqlc.types.Type):
    """Updates settings for the Github app installation"""

    __schema__ = schema
    __field_names__ = ("installation",)
    installation = sgqlc.types.Field(GithubAppInstallation, graphql_name="installation")
    """Updated installation"""


class UpdateGitlabInstallation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("installation",)
    installation = sgqlc.types.Field(GitlabAppInstallation, graphql_name="installation")
    """Updated GitLab installation"""


class UpdateJiraIntegration(sgqlc.types.Type):
    """Update a Jira integration"""

    __schema__ = schema
    __field_names__ = ("jira_integration",)
    jira_integration = sgqlc.types.Field(JiraIntegrationOutput, graphql_name="jiraIntegration")
    """The integration that was updated"""


class UpdateJiraIntegrationWebhookSecret(sgqlc.types.Type):
    """Update the Webhook secret configured for a JIRA service
    integration
    """

    __schema__ = schema
    __field_names__ = ("jira_integration",)
    jira_integration = sgqlc.types.Field(JiraIntegrationOutput, graphql_name="jiraIntegration")
    """The integration that was updated"""


class UpdateLogsIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("logs_integration",)
    logs_integration = sgqlc.types.Field(LogsIntegrationOutput, graphql_name="logsIntegration")
    """The integration that was updated"""


class UpdateLookerCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Looker connection.  Note: This
    mutation only uploads credentials and returns a temporary key. To
    complete the update:  Call testUpdatedCredentialsV2 with the
    returned key as tempCredentialsKey and the same connectionId to
    validate the credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateLookerGitAuthCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Looker connection.  Note: This
    mutation only uploads credentials and returns a temporary key. To
    complete the update:  Call testUpdatedCredentialsV2 with the
    returned key as tempCredentialsKey and the same connectionId to
    validate the credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateMonitorDataQualityDimension(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorDescription(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorLabels(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorName(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorNotes(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorTags(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorsPriorities(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateMonitorsSchedules(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateOpsgenieIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("opsgenie_integration",)
    opsgenie_integration = sgqlc.types.Field(
        OpsgenieIntegrationOutput, graphql_name="opsgenieIntegration"
    )
    """The integration"""


class UpdateOpsgenieIntegrationWebhookSecret(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("opsgenie_integration",)
    opsgenie_integration = sgqlc.types.Field(
        OpsgenieIntegrationOutput, graphql_name="opsgenieIntegration"
    )
    """The integration"""


class UpdatePagerDutyServiceIntegration(sgqlc.types.Type):
    """Update a PagerDuty service integration"""

    __schema__ = schema
    __field_names__ = ("pagerduty_service_integration",)
    pagerduty_service_integration = sgqlc.types.Field(
        PagerDutyServiceIntegrationOutput, graphql_name="pagerdutyServiceIntegration"
    )
    """The integration that was updated"""


class UpdatePagerDutyServiceIntegrationWebhookSecret(sgqlc.types.Type):
    """Update the Webhook secret configured for a PagerDuty service
    integration
    """

    __schema__ = schema
    __field_names__ = ("pagerduty_service_integration",)
    pagerduty_service_integration = sgqlc.types.Field(
        PagerDutyServiceIntegrationOutput, graphql_name="pagerdutyServiceIntegration"
    )
    """The integration that was updated"""


class UpdatePiiFilteringPreferences(sgqlc.types.Type):
    """Update account-wide PII filtering options."""

    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class UpdatePineconeCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Pinecone connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdatePlatformService(sgqlc.types.Type):
    """Update platform service attributes."""

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Boolean indicating if the operation was successful"""


class UpdatePowerBiCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing PowerBi connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateRedshiftCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Redshift connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateSelfHostedCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing self-hosted connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateServiceNowIntegration(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("servicenow_integration",)
    servicenow_integration = sgqlc.types.Field(
        ServiceNowIntegrationOutput, graphql_name="servicenowIntegration"
    )
    """The integration that was updated"""


class UpdateSlackChannelsMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")


class UpdateSnowflakeCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Snowflake connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateStatementOption(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success",)
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Whether the mutation succeeded."""


class UpdateStreamingClusterNameMutation(sgqlc.types.Type):
    """Update a streaming cluster name."""

    __schema__ = schema
    __field_names__ = ("streaming_cluster",)
    streaming_cluster = sgqlc.types.Field(StreamingCluster, graphql_name="streamingCluster")


class UpdateStreamingSystemNameMutation(sgqlc.types.Type):
    """Update a streaming system name."""

    __schema__ = schema
    __field_names__ = ("streaming_system",)
    streaming_system = sgqlc.types.Field(StreamingSystem, graphql_name="streamingSystem")


class UpdateTableauAssetWarning(sgqlc.types.Type):
    """Updates a warning on an asset."""

    __schema__ = schema
    __field_names__ = ("tableau_warning_id", "message")
    tableau_warning_id = sgqlc.types.Field(String, graphql_name="tableauWarningId")
    """ID of the created warning in Tableau ID space."""

    message = sgqlc.types.Field(String, graphql_name="message")
    """The updated message of the warning"""


class UpdateTableauCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Tableau connection.  Note:
    This mutation only uploads credentials and returns a temporary
    key. To complete the update:  Call testUpdatedCredentialsV2 with
    the returned key as tempCredentialsKey and the same connectionId
    to validate the credentials  Call updateCredentialsV2 with the
    same tempCredentialsKey and connectionId to persist the changes.
    See full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateTransactionalDbCredentialsV2Mutation(sgqlc.types.Type):
    """Update credentials for an existing Transactional DB connection.
    Note: This mutation only uploads credentials and returns a
    temporary key. To complete the update:  Call
    testUpdatedCredentialsV2 with the returned key as
    tempCredentialsKey and the same connectionId to validate the
    credentials  Call updateCredentialsV2 with the same
    tempCredentialsKey and connectionId to persist the changes.  See
    full instructions here -
    https://docs.getmontecarlo.com/docs/updating-integrations#/.
    """

    __schema__ = schema
    __field_names__ = ("result",)
    result = sgqlc.types.Field(UpdateCredentialsV2Result, graphql_name="result")


class UpdateUserAuthorizationGroupMembership(sgqlc.types.Type):
    """Update a user's authorization group membership. Authenticated user
    must have permission to manage users.
    """

    __schema__ = schema
    __field_names__ = ("added_to_groups", "removed_from_groups")
    added_to_groups = sgqlc.types.Field(
        sgqlc.types.list_of(AuthorizationGroupOutput), graphql_name="addedToGroups"
    )
    """List of groups user was added to."""

    removed_from_groups = sgqlc.types.Field(
        sgqlc.types.list_of(AuthorizationGroupOutput), graphql_name="removedFromGroups"
    )
    """List of groups user was removed from."""


class UpdateUserPersona(sgqlc.types.Type):
    """Update user's persona for personalised experience."""

    __schema__ = schema
    __field_names__ = ("user",)
    user = sgqlc.types.Field("User", graphql_name="user")


class UpdateUserStatePayload(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("user", "client_mutation_id")
    user = sgqlc.types.Field("User", graphql_name="user")

    client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")


class UpdateWebexIntegration(sgqlc.types.Type):
    """Update a Webex integration"""

    __schema__ = schema
    __field_names__ = ("webex_integration",)
    webex_integration = sgqlc.types.Field("WebexIntegrationOutput", graphql_name="webexIntegration")
    """The integration that was updated"""


class UpdateWorkspaceIdentifier(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("value",)
    value = sgqlc.types.Field(String, graphql_name="value")
    """This account's workspace identifier"""


class UpgradeAgent(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("upgrade_result",)
    upgrade_result = sgqlc.types.Field(GenericScalar, graphql_name="upgradeResult")
    """The result object returned from the agent."""


class UploadAirflowDagResult(sgqlc.types.Type):
    """Uploads the result for a DAG run."""

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Result"""


class UploadAirflowSlaMisses(sgqlc.types.Type):
    """Uploads a list of SLAs missed for a DAG."""

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Result"""


class UploadAirflowTaskResult(sgqlc.types.Type):
    """Uploads the result for a DAG run."""

    __schema__ = schema
    __field_names__ = ("ok",)
    ok = sgqlc.types.Field(Boolean, graphql_name="ok")
    """Result"""


class UploadWarehouseCredentialsMutation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("key",)
    key = sgqlc.types.Field(String, graphql_name="key")


class UsageAlertConfigOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("threshold", "emails", "disabled")
    threshold = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="threshold")
    """Usage threshold that triggers the alert"""

    emails = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="emails"
    )
    """List of recipients"""

    disabled = sgqlc.types.Field(Boolean, graphql_name="disabled")
    """Disable the alert (optional)"""


class UserAuthorizationOutput(sgqlc.types.Type):
    """The aggregate authorization policy for a user."""

    __schema__ = schema
    __field_names__ = (
        "groups",
        "domain_restrictions",
        "permissions",
        "performance_dashboard_access",
        "can_edit_table_monitors",
    )
    groups = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="groups")
    """List of the groups this user is a member of."""

    domain_restrictions = sgqlc.types.Field(
        sgqlc.types.list_of("DomainRestriction"), graphql_name="domainRestrictions"
    )
    """Union of all discovered domain restrictions for the user. If
    empty, user has no restrictions. Note this list may not
    necessarily match the domain restrictions for a particular
    permission. This is simply a complete list of all discovered
    restrictions for the user--always check the restrictions on a
    permission against its own list of restrictions.
    """

    permissions = sgqlc.types.Field(
        sgqlc.types.list_of("UserPermission"), graphql_name="permissions"
    )
    """Full list of permissions with resolved policy for the user."""

    performance_dashboard_access = sgqlc.types.Field(
        "ValidatePerformanceDashboardAccessResponse", graphql_name="performanceDashboardAccess"
    )

    can_edit_table_monitors = sgqlc.types.Field(Boolean, graphql_name="canEditTableMonitors")
    """Whether the user can create, update or delete table monitors."""


class UserBasicInfoConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count", "edge_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UserBasicInfoEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")


class UserBasicInfoEdge(sgqlc.types.Type):
    """A Relay edge containing a `UserBasicInfo` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UserBasicInfo", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UserBlastRadius2(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("username", "query_count", "tables")
    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")
    """The username who performed the query"""

    query_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="queryCount")
    """The number of queries performed by user in the timeframe"""

    tables = sgqlc.types.Field(sgqlc.types.list_of("UserTableBlastRadius"), graphql_name="tables")
    """The table information for the user"""


class UserConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count", "edge_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UserEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")


class UserDefinedMonitorConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UserDefinedMonitorEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class UserDefinedMonitorConnectionV2Connection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UserDefinedMonitorConnectionV2Edge")),
        graphql_name="edges",
    )
    """Contains the nodes in this connection."""


class UserDefinedMonitorConnectionV2Edge(sgqlc.types.Type):
    """A Relay edge containing a `UserDefinedMonitorConnectionV2` and its
    cursor.
    """

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UserDefinedMonitorV2", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UserDefinedMonitorEdge(sgqlc.types.Type):
    """A Relay edge containing a `UserDefinedMonitor` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UserDefinedMonitor", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UserEdge(sgqlc.types.Type):
    """A Relay edge containing a `User` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("User", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UserInfoOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("user_email", "user_id", "first_name", "last_name")
    user_email = sgqlc.types.Field(String, graphql_name="userEmail")
    """Email of the user."""

    user_id = sgqlc.types.Field(String, graphql_name="userId")
    """UUID of the user."""

    first_name = sgqlc.types.Field(String, graphql_name="firstName")
    """First name of the user."""

    last_name = sgqlc.types.Field(String, graphql_name="lastName")
    """Last name of the user."""


class UserInviteConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count", "edge_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UserInviteEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")

    edge_count = sgqlc.types.Field(Int, graphql_name="edgeCount")


class UserInviteEdge(sgqlc.types.Type):
    """A Relay edge containing a `UserInvite` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UserInvite", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UserOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("email", "full_name")
    email = sgqlc.types.Field(String, graphql_name="email")

    full_name = sgqlc.types.Field(String, graphql_name="fullName")


class UserPermission(sgqlc.types.Type):
    """An individual permission policy for a user."""

    __schema__ = schema
    __field_names__ = ("permission", "effect", "domain_restriction_ids")
    permission = sgqlc.types.Field(Permission, graphql_name="permission")
    """Enum name of permission this policy applies to."""

    effect = sgqlc.types.Field(PermissionEffect, graphql_name="effect")
    """The effective policy for this permission for the user."""

    domain_restriction_ids = sgqlc.types.Field(
        sgqlc.types.list_of(UUID), graphql_name="domainRestrictionIds"
    )
    """If permission allowed and user is restricted, union of domain IDs
    for which user has this permission.
    """


class UserSettingsConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("UserSettingsEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class UserSettingsEdge(sgqlc.types.Type):
    """A Relay edge containing a `UserSettings` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("UserSettings", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class UserTableBlastRadius(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("full_table_id", "query_count", "mcon")
    full_table_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullTableId")
    """The incident table that was queried"""

    query_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="queryCount")
    """The number of queries performed by user in the timeframe"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """The table mcon"""


class UserTutorial(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "account_uuid",
        "user",
        "tutorial_name",
        "tutorial_started",
        "tutorial_completed",
        "state",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")
    """Account identifier"""

    user = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="user")
    """The user which the tutorial step is relevant for"""

    tutorial_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tutorialName")
    """The unique name of the tutorial"""

    tutorial_started = sgqlc.types.Field(DateTime, graphql_name="tutorialStarted")
    """The time the tutorial was started"""

    tutorial_completed = sgqlc.types.Field(DateTime, graphql_name="tutorialCompleted")
    """The time the tutorial was completed"""

    state = sgqlc.types.Field(TutorialStatusType, graphql_name="state")
    """Tutorial state"""


class VCSSummary(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("total_count", "available_filters")
    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total count of pull requests found"""

    available_filters = sgqlc.types.Field(
        sgqlc.types.list_of(AvailableFilter), graphql_name="availableFilters"
    )
    """Filters available in the result"""


class ValidateCron(sgqlc.types.Type):
    """Validate a CRON expression"""

    __schema__ = schema
    __field_names__ = ("success", "error")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the CRON expression is valid"""

    error = sgqlc.types.Field(String, graphql_name="error")
    """Error message if the CRON expression is not valid"""


class ValidateDataAssetAccessResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "validation_results")
    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """Indicates whether the operation was completed successfully"""

    validation_results = sgqlc.types.Field(
        sgqlc.types.list_of(TestCredentialsV2Response), graphql_name="validationResults"
    )
    """List of validation results"""


class ValidatePerformanceDashboardAccessResponse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("success", "code", "denial_reason")
    success = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="success")
    """Whether the user has access to the performance dashboard."""

    code = sgqlc.types.Field(PerformanceDashboardAccessValidationCode, graphql_name="code")
    """The code for the validation result."""

    denial_reason = sgqlc.types.Field(String, graphql_name="denialReason")
    """The reason for the validation failure result."""


class Validation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "description", "is_prerequisite", "periodic_validation")
    name = sgqlc.types.Field(String, graphql_name="name")
    """Name of the validation."""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Description of the validation."""

    is_prerequisite = sgqlc.types.Field(Boolean, graphql_name="isPrerequisite")
    """Whether this is an essential prerequisite for other validations to
    be run. Prerequisite validations should be run serially before
    non-prerequisite validations are run.
    """

    periodic_validation = sgqlc.types.Field(Boolean, graphql_name="periodicValidation")
    """Whether this validation is executed periodically or not."""


class ValidationFailure(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("cause", "stack_trace", "friendly_message", "resolution")
    cause = sgqlc.types.Field(String, graphql_name="cause")
    """Cause of the validation failure."""

    stack_trace = sgqlc.types.Field(String, graphql_name="stackTrace")
    """Stack trace of the failure."""

    friendly_message = sgqlc.types.Field(String, graphql_name="friendlyMessage")
    """A friendly error message."""

    resolution = sgqlc.types.Field(String, graphql_name="resolution")
    """Helpful instructions on how to resolve the validation failure."""


class VariableDefinition(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "runtime", "values")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    runtime = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="runtime")

    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="values",
    )


class VariableValue(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")


class VolumeChangeAutomatedAlertConditionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("sensitivity_level",)
    sensitivity_level = sgqlc.types.Field(
        sgqlc.types.non_null(SensitivityLevels), graphql_name="sensitivityLevel"
    )
    """Sensitivity for automated thresholds"""


class VolumeChangeDetectorThresholdOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("upper", "lower")
    upper = sgqlc.types.Field(sgqlc.types.non_null(ThresholdLMHType), graphql_name="upper")
    """Upper thresholds in percent"""

    lower = sgqlc.types.Field(sgqlc.types.non_null(ThresholdLMHType), graphql_name="lower")
    """Lower thresholds in percent"""


class VolumeChangeExplicitAlertConditionOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "start_time",
        "interval_minutes",
        "interval_crontab",
        "interval_crontab_day_or",
        "timezone",
        "upper_threshold",
        "lower_threshold",
        "threshold_lookback_minutes",
    )
    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """Start time of the collection"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")
    """Collection interval in minutes"""

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="intervalCrontab"
    )
    """Collection interval in crontab format"""

    interval_crontab_day_or = sgqlc.types.Field(Boolean, graphql_name="intervalCrontabDayOr")
    """If true, use default cron behavior and run when day-of-month OR
    day-of-week match. If false, use alternate behavior and run when
    day-of-month AND day-of-week match.
    """

    timezone = sgqlc.types.Field(String, graphql_name="timezone")
    """Timezone for daylight savings and interpreting cron expressions"""

    upper_threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="upperThreshold")
    """Upper threshold in percent"""

    lower_threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="lowerThreshold")
    """Lower threshold in percent"""

    threshold_lookback_minutes = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="thresholdLookbackMinutes"
    )
    """Threshold lookback in minutes"""


class VolumeChangeTableMonitorConfigOutput(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "status",
        "metric",
        "most_recent_value",
        "collection_status",
        "supports_explicit_alert_condition",
        "tags",
        "data_quality_dimension",
        "alert_condition",
        "detector_threshold",
        "most_recent_total_size",
    )
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the underlying OOTB replacement rule"""

    status = sgqlc.types.Field(
        sgqlc.types.non_null(ConsolidatedMonitorStatusType), graphql_name="status"
    )
    """Detection status"""

    metric = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="metric")
    """Name of metric for which the detector is active"""

    most_recent_value = sgqlc.types.Field(Float, graphql_name="mostRecentValue")
    """Most recent value change analyzed by the detector"""

    collection_status = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionStatusOutput), graphql_name="collectionStatus"
    )
    """Collection status information"""

    supports_explicit_alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="supportsExplicitAlertCondition"
    )
    """True if using the explicit alert condition is supported"""

    tags = sgqlc.types.Field(sgqlc.types.list_of(TagKeyValuePairOutput), graphql_name="tags")
    """Tags for the alert condition"""

    data_quality_dimension = sgqlc.types.Field(String, graphql_name="dataQualityDimension")
    """Data quality dimension for the alert condition"""

    alert_condition = sgqlc.types.Field(
        sgqlc.types.non_null("VolumeChangeAlertConditionOutput"), graphql_name="alertCondition"
    )
    """Alert condition configuration"""

    detector_threshold = sgqlc.types.Field(
        sgqlc.types.non_null(VolumeChangeDetectorThresholdOutput), graphql_name="detectorThreshold"
    )
    """Detector volume change threshold"""

    most_recent_total_size = sgqlc.types.Field(Float, graphql_name="mostRecentTotalSize")
    """Most recent total size value collected"""


class Warehouse(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "id",
        "created_time",
        "updated_time",
        "last_update_user",
        "uuid",
        "name",
        "connection_type",
        "credentials_s3_key",
        "bq_project_id",
        "account",
        "data_collector",
        "created_on",
        "is_deleted",
        "deleted_at",
        "deleted_by",
        "config",
        "created_by",
        "connections",
        "tables",
        "incidents",
        "events",
        "projects",
        "datasets",
        "fivetran_destinations",
        "monitored_table_rules",
        "dashboards",
        "mute_rule",
        "user_has_access_to_sample_data",
        "data_sampling_enabled",
        "data_sampling_restricted",
        "value_ingestion_enabled",
        "value_based_threshold_enabled",
        "labeled_value_based_threshold_enabled",
        "custom_sql_sampling_supported",
        "custom_sql_sampling_enabled",
        "supports_reproduction_queries",
        "supports_sampling",
        "supports_validation_monitors",
        "supports_metric_monitors",
        "supports_comparison_monitors",
        "supports_custom_sql_rules",
        "supports_high_segment_count",
        "supports_activity_filters",
        "supports_metric_segmentation",
        "supports_metric_aggregation",
        "mcon",
        "metadata_connection",
        "metadata_schedule",
        "create_alerts_in_datasource",
        "custom_monitor_count",
        "total_monitor_count",
        "supports_transform",
        "warehouse_relations",
    )
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    name = sgqlc.types.Field(String, graphql_name="name")

    connection_type = sgqlc.types.Field(
        sgqlc.types.non_null(WarehouseModelConnectionType), graphql_name="connectionType"
    )

    credentials_s3_key = sgqlc.types.Field(String, graphql_name="credentialsS3Key")

    bq_project_id = sgqlc.types.Field(String, graphql_name="bqProjectId")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    data_collector = sgqlc.types.Field(DataCollector, graphql_name="dataCollector")

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    deleted_by = sgqlc.types.Field("User", graphql_name="deletedBy")

    config = sgqlc.types.Field(JSONString, graphql_name="config")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """User who created this warehouse"""

    connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connections",
    )

    tables = sgqlc.types.Field(
        sgqlc.types.non_null("WarehouseTableConnection"),
        graphql_name="tables",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `full_table_id` (`String`)None
    """

    incidents = sgqlc.types.Field(
        sgqlc.types.non_null(IncidentConnection),
        graphql_name="incidents",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Warehouse an incident belongs to

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    events = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="events",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    projects = sgqlc.types.Field(
        sgqlc.types.non_null(ProjectConnection),
        graphql_name="projects",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `project` (`String`)None
    * `mcon` (`String`)None
    * `uuid` (`UUID`)None
    """

    datasets = sgqlc.types.Field(
        sgqlc.types.non_null(DatasetConnection),
        graphql_name="datasets",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("dataset", sgqlc.types.Arg(String, graphql_name="dataset", default=None)),
                ("project", sgqlc.types.Arg(String, graphql_name="project", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `dataset` (`String`)None
    * `project` (`String`)None
    """

    fivetran_destinations = sgqlc.types.Field(
        sgqlc.types.non_null(FivetranDestinationConnection),
        graphql_name="fivetranDestinations",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    monitored_table_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitoredTableRuleObject))),
        graphql_name="monitoredTableRules",
    )

    dashboards = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerDashboardTypeConnection),
        graphql_name="dashboards",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    mute_rule = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(EventMutingRule))),
        graphql_name="muteRule",
    )

    user_has_access_to_sample_data = sgqlc.types.Field(
        Boolean, graphql_name="userHasAccessToSampleData"
    )
    """Indicates whether the current user has access to the sample data
    from the warehouse
    """

    data_sampling_enabled = sgqlc.types.Field(Boolean, graphql_name="dataSamplingEnabled")
    """Indicates whether the customer has opted out of sampling for the
    warehouse
    """

    data_sampling_restricted = sgqlc.types.Field(Boolean, graphql_name="dataSamplingRestricted")
    """Indicates whether the customer has opted into sampling
    restrictions for the warehouse
    """

    value_ingestion_enabled = sgqlc.types.Field(Boolean, graphql_name="valueIngestionEnabled")
    """Indicates whether the customer has opted out of value ingestion
    for the warehouse (opting out of sampling disables this as well)
    """

    value_based_threshold_enabled = sgqlc.types.Field(
        Boolean, graphql_name="valueBasedThresholdEnabled"
    )
    """Indicates whether rules with value-based thresholds can be created
    and executed
    """

    labeled_value_based_threshold_enabled = sgqlc.types.Field(
        Boolean, graphql_name="labeledValueBasedThresholdEnabled"
    )
    """Indicates whether rules with labeled-value-based thresholds can be
    created and executed
    """

    custom_sql_sampling_supported = sgqlc.types.Field(
        Boolean, graphql_name="customSqlSamplingSupported"
    )
    """Indicates whether the DC version for this warehouse supports
    custom SQL sampling
    """

    custom_sql_sampling_enabled = sgqlc.types.Field(
        Boolean, graphql_name="customSqlSamplingEnabled"
    )
    """Indicates whether output of qualifying custom SQL rules in this
    warehouse will be sampled
    """

    supports_reproduction_queries = sgqlc.types.Field(
        Boolean, graphql_name="supportsReproductionQueries"
    )

    supports_sampling = sgqlc.types.Field(Boolean, graphql_name="supportsSampling")

    supports_validation_monitors = sgqlc.types.Field(
        Boolean, graphql_name="supportsValidationMonitors"
    )
    """Indicates if the warehouse supports Validation monitors"""

    supports_metric_monitors = sgqlc.types.Field(Boolean, graphql_name="supportsMetricMonitors")
    """Indicates if the warehouse supports Metric monitors"""

    supports_comparison_monitors = sgqlc.types.Field(
        Boolean, graphql_name="supportsComparisonMonitors"
    )
    """Indicates if the warehouse supports Comparison monitors"""

    supports_custom_sql_rules = sgqlc.types.Field(Boolean, graphql_name="supportsCustomSqlRules")
    """Indicates if the warehouse supports SQL rules"""

    supports_high_segment_count = sgqlc.types.Field(
        Boolean, graphql_name="supportsHighSegmentCount"
    )
    """Indicates if the warehouse supports high segment count mode"""

    supports_activity_filters = sgqlc.types.Field(Boolean, graphql_name="supportsActivityFilters")
    """Indicates if the warehouse supports activity filters"""

    supports_metric_segmentation = sgqlc.types.Field(
        Boolean, graphql_name="supportsMetricSegmentation"
    )
    """Indicates if the warehouse supports segmentation in metric
    monitors
    """

    supports_metric_aggregation = sgqlc.types.Field(
        Boolean, graphql_name="supportsMetricAggregation"
    )
    """Indicates if the warehouse supports grouping in metric monitors"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON for the warehouse"""

    metadata_connection = sgqlc.types.Field(Connection, graphql_name="metadataConnection")
    """The connection used for metadata collection of the warehouse"""

    metadata_schedule = sgqlc.types.Field(ScheduleConfigOutput, graphql_name="metadataSchedule")
    """The schedule used for default metadata collection"""

    create_alerts_in_datasource = sgqlc.types.Field(
        Boolean, graphql_name="createAlertsInDatasource"
    )
    """Indicates whether it is enabled to create incidents in the
    datasource when supported
    """

    custom_monitor_count = sgqlc.types.Field(Int, graphql_name="customMonitorCount")
    """The number of user created monitors on this warehouse."""

    total_monitor_count = sgqlc.types.Field(Int, graphql_name="totalMonitorCount")
    """The number of table monitors and user created monitors on this
    warehouse.
    """

    supports_transform = sgqlc.types.Field(Boolean, graphql_name="supportsTransform")
    """Indicates whether the warehouse supports transform operations"""

    warehouse_relations = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseRelation"), graphql_name="warehouseRelations"
    )
    """List of relations this warehouse has to other warehouses"""


class WarehouseRelation(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("relation_type", "target_warehouse_uuid")
    relation_type = sgqlc.types.Field(WarehouseRelationType, graphql_name="relationType")

    target_warehouse_uuid = sgqlc.types.Field(UUID, graphql_name="targetWarehouseUuid")
    """UUID of the target warehouse"""


class WarehouseTableConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("WarehouseTableEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""


class WarehouseTableEdge(sgqlc.types.Type):
    """A Relay edge containing a `WarehouseTable` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("WarehouseTable", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class WarehouseTableHealthConnection(sgqlc.types.relay.Connection):
    __schema__ = schema
    __field_names__ = ("page_info", "edges", "total_count")
    page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo")
    """Pagination data for this connection."""

    edges = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of("WarehouseTableHealthEdge")), graphql_name="edges"
    )
    """Contains the nodes in this connection."""

    total_count = sgqlc.types.Field(Int, graphql_name="totalCount")
    """Total count of elements in the result set."""


class WarehouseTableHealthEdge(sgqlc.types.Type):
    """A Relay edge containing a `WarehouseTableHealth` and its cursor."""

    __schema__ = schema
    __field_names__ = ("node", "cursor")
    node = sgqlc.types.Field("WarehouseTableHealth", graphql_name="node")
    """The item at the end of the edge"""

    cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor")
    """A cursor for use in pagination"""


class WarehouseTableIncident(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("uuid", "category", "feedback")
    uuid = sgqlc.types.Field(UUID, graphql_name="uuid")
    """UUID of the incident"""

    category = sgqlc.types.Field(IncidentCategory, graphql_name="category")
    """Category used to classify the incident"""

    feedback = sgqlc.types.Field(String, graphql_name="feedback")
    """Status for the incident"""


class WarehouseTagsCollectionSetting(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("is_enabled",)
    is_enabled = sgqlc.types.Field(Boolean, graphql_name="isEnabled")


class WebexIntegrationOutput(sgqlc.types.Type):
    """A Webex integration"""

    __schema__ = schema
    __field_names__ = (
        "integration_id",
        "integration_name",
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
    )
    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """The integration ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """A short name to identify the integration"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the integration was created"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """When the integration was last updated"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who created the integration"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the integration"""


class WebexTestCredentialsOutput(sgqlc.types.Type):
    """A Webex test credentials result"""

    __schema__ = schema
    __field_names__ = ("valid_credentials",)
    valid_credentials = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="validCredentials"
    )
    """Returns if the credentials are valid"""


class WebhookHeader(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")
    """The header field name"""

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")
    """The header field value"""


class WebhookStatus(sgqlc.types.Type):
    """Webhook status information for an integration"""

    __schema__ = schema
    __field_names__ = ("status", "last_received")
    status = sgqlc.types.Field(sgqlc.types.non_null(WebhookStatusValue), graphql_name="status")
    """Status of webhook setup: ACTIVE, STALE, or NEVER_RECEIVED"""

    last_received = sgqlc.types.Field(DateTime, graphql_name="lastReceived")
    """Timestamp when the last webhook event was received"""


class WhereConditionSegments(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("time_series_uuids", "where_conditions", "last_where_condition")
    time_series_uuids = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UUID))),
        graphql_name="timeSeriesUuids",
    )

    where_conditions = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="whereConditions"
    )

    last_where_condition = sgqlc.types.Field(String, graphql_name="lastWhereCondition")
    """Value to use as 'after' for pagination"""


class WidgetDataResponseType(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = (
        "data_frame",
        "sql_query",
        "response_metadata",
        "total_row_count",
        "limit",
        "offset",
    )
    data_frame = sgqlc.types.Field(JSONString, graphql_name="dataFrame")

    sql_query = sgqlc.types.Field(String, graphql_name="sqlQuery")
    """Raw SQL query that produced this data"""

    response_metadata = sgqlc.types.Field(
        QueryResponseMetadataType, graphql_name="responseMetadata"
    )
    """Provides metadata that describes how response is structured."""

    total_row_count = sgqlc.types.Field(Int, graphql_name="totalRowCount")

    limit = sgqlc.types.Field(Int, graphql_name="limit")

    offset = sgqlc.types.Field(Int, graphql_name="offset")


class WildcardTemplate(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("template_name", "template_regex")
    template_name = sgqlc.types.Field(String, graphql_name="templateName")
    """Name describing the template format (i.e. _YYYYMMD"""

    template_regex = sgqlc.types.Field(String, graphql_name="templateRegex")
    """Regex used to match the template format"""


class WildcardTemplates(sgqlc.types.Type):
    __schema__ = schema
    __field_names__ = ("templates",)
    templates = sgqlc.types.Field(sgqlc.types.list_of(WildcardTemplate), graphql_name="templates")


class AdfJob(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "account",
        "generates_incidents",
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "mcon",
        "job_id",
        "job_name",
        "job_description",
        "job_folder",
        "last_run_date",
        "last_webhook_received",
        "runs",
        "etl_type",
        "source_tables",
        "dest_tables",
        "recent_run_count",
        "generates_alerts",
        "tasks",
        "job_url",
        "webhook_status",
    )
    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    generates_incidents = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesIncidents"
    )

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the pipeline"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Job ID"""

    job_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobName")
    """Job Name"""

    job_description = sgqlc.types.Field(String, graphql_name="jobDescription")
    """Job Description"""

    job_folder = sgqlc.types.Field(String, graphql_name="jobFolder")
    """Job Folder"""

    last_run_date = sgqlc.types.Field(DateTime, graphql_name="lastRunDate")
    """The date of the last run"""

    last_webhook_received = sgqlc.types.Field(DateTime, graphql_name="lastWebhookReceived")
    """Timestamp of the last webhook event received for this job"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(AdfJobRunConnection),
        graphql_name="runs",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Job associated with the run

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    etl_type = sgqlc.types.Field(sgqlc.types.non_null(EtlType), graphql_name="etlType")
    """Etl type of the job"""

    source_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="sourceTables"
    )
    """Tables read from in this job"""

    dest_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="destTables"
    )
    """Tables modified in this job"""

    recent_run_count = sgqlc.types.Field(Int, graphql_name="recentRunCount")
    """Number of runs of this job within the last 30 days"""

    generates_alerts = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts"
    )
    """Whether this job generates alerts when it fails"""

    tasks = sgqlc.types.Field(sgqlc.types.list_of("AdfTask"), graphql_name="tasks")
    """Tasks in this job"""

    job_url = sgqlc.types.Field(String, graphql_name="jobUrl")
    """Url of the job page in the original ADF environment"""

    webhook_status = sgqlc.types.Field(WebhookStatus, graphql_name="webhookStatus")
    """Webhook status info for this job"""


class AdfJobRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "success",
        "job_id",
        "run_id",
        "started_at",
        "finished_at",
        "message",
        "duration",
        "status",
        "associated_job",
        "run_url",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the event"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """run was successful or not"""

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Job ID"""

    run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="runId")
    """Run ID"""

    started_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startedAt")
    """Time the run started"""

    finished_at = sgqlc.types.Field(DateTime, graphql_name="finishedAt")
    """Time the run ended"""

    message = sgqlc.types.Field(String, graphql_name="message")
    """Error message for the run"""

    duration = sgqlc.types.Field(Float, graphql_name="duration")
    """Duration of the run in seconds"""

    status = sgqlc.types.Field(sgqlc.types.non_null(AdfJobRunModelStatus), graphql_name="status")
    """Status of the run"""

    associated_job = sgqlc.types.Field(AdfJob, graphql_name="associatedJob")
    """Job associated with the run"""

    run_url = sgqlc.types.Field(String, graphql_name="runUrl")
    """Url of the run page in the original ADF environment"""


class AdfTask(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "account",
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "mcon",
        "adf_job_id",
        "task_id",
        "task_name",
        "task_type",
        "runs",
    )
    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the pipeline"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    adf_job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="adfJobId")
    """Job ID"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID"""

    task_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskName")
    """Task Name"""

    task_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskType")
    """Task Type"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(AdfTaskRunConnection),
        graphql_name="runs",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Task associated with the run

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class AdfTaskRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "success",
        "job_id",
        "run_id",
        "started_at",
        "finished_at",
        "message",
        "duration",
        "status",
        "job_run_id",
        "task_id",
        "associated_task",
        "task_mcon",
        "job_mcon",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the event"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """run was successful or not"""

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Job ID"""

    run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="runId")
    """Run ID"""

    started_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startedAt")
    """Time the run started"""

    finished_at = sgqlc.types.Field(DateTime, graphql_name="finishedAt")
    """Time the run ended"""

    message = sgqlc.types.Field(String, graphql_name="message")
    """Error message for the run"""

    duration = sgqlc.types.Field(Float, graphql_name="duration")
    """Duration of the run in seconds"""

    status = sgqlc.types.Field(sgqlc.types.non_null(AdfTaskRunModelStatus), graphql_name="status")
    """Status of the run"""

    job_run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobRunId")
    """Job Run ID"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID"""

    associated_task = sgqlc.types.Field(AdfTask, graphql_name="associatedTask")
    """Task associated with the run"""

    task_mcon = sgqlc.types.Field(String, graphql_name="taskMcon")
    """MCON of Task for provided task_id"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of Job for provided job_id"""


class AgentTraceTable(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account",
        "table",
        "span_format",
        "schedule",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique ID of the Agent Trace Table."""

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    table = sgqlc.types.Field(sgqlc.types.non_null("WarehouseTable"), graphql_name="table")
    """Agent trace table"""

    span_format = sgqlc.types.Field(
        sgqlc.types.non_null(AgentTraceTableModelSpanFormat), graphql_name="spanFormat"
    )
    """Format of spans in the table."""

    schedule = sgqlc.types.Field(
        sgqlc.types.non_null(DataCollectorSchedule), graphql_name="schedule"
    )


class AirflowDag(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "account",
        "generates_incidents",
        "uuid",
        "resource",
        "mcon",
        "dag_id",
        "env_name",
        "last_run_date",
        "last_webhook_received",
        "runs",
        "etl_type",
        "source_tables",
        "dest_tables",
        "recent_run_count",
        "generates_alerts",
        "tasks",
        "job_url",
        "job_id",
        "job_name",
        "webhook_status",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    generates_incidents = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesIncidents"
    )

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the pipeline"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    dag_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dagId")
    """DAG ID"""

    env_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="envName")
    """AirFlow environment name"""

    last_run_date = sgqlc.types.Field(DateTime, graphql_name="lastRunDate")
    """The date of the last run"""

    last_webhook_received = sgqlc.types.Field(DateTime, graphql_name="lastWebhookReceived")
    """Timestamp of the last webhook event received for this DAG"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowDagRunConnection),
        graphql_name="runs",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Dag associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    etl_type = sgqlc.types.Field(sgqlc.types.non_null(EtlType), graphql_name="etlType")
    """Etl type of the job"""

    source_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="sourceTables"
    )
    """Tables read from in this job"""

    dest_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="destTables"
    )
    """Tables modified in this job"""

    recent_run_count = sgqlc.types.Field(Int, graphql_name="recentRunCount")
    """Number of runs of this job within the last 30 days"""

    generates_alerts = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts"
    )
    """Whether this job generates alerts when it fails"""

    tasks = sgqlc.types.Field(sgqlc.types.list_of("AirflowTask"), graphql_name="tasks")
    """Tasks in this dag"""

    job_url = sgqlc.types.Field(String, graphql_name="jobUrl")
    """Url of the job page in the original ADF environment"""

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Same as DagId"""

    job_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobName")
    """Same as DagId"""

    webhook_status = sgqlc.types.Field(WebhookStatus, graphql_name="webhookStatus")
    """Webhook status info for this DAG"""


class AirflowDagRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "success",
        "execution_date",
        "start_date",
        "end_date",
        "state",
        "dag_id",
        "run_id",
        "env_name",
        "reason",
        "payload",
        "associated_dag",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the event"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """run was successful or not"""

    execution_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="executionDate")
    """run execution_date"""

    start_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startDate")
    """run start_date"""

    end_date = sgqlc.types.Field(DateTime, graphql_name="endDate")
    """run end_date"""

    state = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="state")
    """run state"""

    dag_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dagId")
    """DAG ID"""

    run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="runId")
    """Run ID"""

    env_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="envName")
    """AirFlow environment name"""

    reason = sgqlc.types.Field(String, graphql_name="reason")
    """DAG run reason"""

    payload = sgqlc.types.Field(sgqlc.types.non_null(JSONString), graphql_name="payload")
    """DAG run payload"""

    associated_dag = sgqlc.types.Field(AirflowDag, graphql_name="associatedDag")
    """Dag associated with the event"""


class AirflowRca(sgqlc.types.Type, IBaseRca):
    __schema__ = schema
    __field_names__ = (
        "rca_subtype",
        "dag_id",
        "task_id",
        "run_id",
        "error_msg_base64",
        "upstream_error_msg_base64",
        "upstream_failed_task_id",
        "start_time",
        "mcon",
    )
    rca_subtype = sgqlc.types.Field(String, graphql_name="rcaSubtype")
    """'skipped', 'failed' or 'upstream_failed' values"""

    dag_id = sgqlc.types.Field(String, graphql_name="dagId")
    """Airflow id of the DAG"""

    task_id = sgqlc.types.Field(String, graphql_name="taskId")
    """Airflow id of the task"""

    run_id = sgqlc.types.Field(String, graphql_name="runId")
    """Airflow specific run id of failed task"""

    error_msg_base64 = sgqlc.types.Field(String, graphql_name="errorMsgBase64")
    """Failed error msg in base 64 encoding"""

    upstream_error_msg_base64 = sgqlc.types.Field(String, graphql_name="upstreamErrorMsgBase64")
    """Failed upstream error msg in base 64 encoding"""

    upstream_failed_task_id = sgqlc.types.Field(String, graphql_name="upstreamFailedTaskId")
    """Relevant for failed failed upstream task status which caused the
    task to not run
    """

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """When the Airflow task started"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON of the associated table"""


class AirflowTask(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "account",
        "uuid",
        "resource",
        "mcon",
        "dag_id",
        "task_id",
        "env_name",
        "runs",
        "source_tables",
        "dest_tables",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the pipeline"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    dag_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dagId")
    """DAG ID"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID"""

    env_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="envName")
    """AirFlow environment name"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(AirflowTaskRunConnection),
        graphql_name="runs",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """task associated with the event

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    source_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="sourceTables"
    )
    """Tables read from in this task"""

    dest_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="destTables"
    )
    """Tables modified in this task"""


class AirflowTaskRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "success",
        "execution_date",
        "start_date",
        "end_date",
        "state",
        "dag_id",
        "run_id",
        "task_id",
        "env_name",
        "next_retry_date",
        "attempt_number",
        "duration",
        "exception_message",
        "payload",
        "associated_task",
        "urls",
        "task_mcon",
        "job_mcon",
        "log_url",
        "attempts",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the event"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """run was successful or not"""

    execution_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="executionDate")
    """run execution_date"""

    start_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startDate")
    """run start_date"""

    end_date = sgqlc.types.Field(DateTime, graphql_name="endDate")
    """run end_date"""

    state = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="state")
    """run state"""

    dag_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dagId")
    """DAG ID"""

    run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="runId")
    """DAG Run ID"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID"""

    env_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="envName")
    """AirFlow environment name"""

    next_retry_date = sgqlc.types.Field(DateTime, graphql_name="nextRetryDate")
    """Task next retry datetime"""

    attempt_number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="attemptNumber")
    """Task attempt number"""

    duration = sgqlc.types.Field(Float, graphql_name="duration")
    """Task run duration in seconds"""

    exception_message = sgqlc.types.Field(String, graphql_name="exceptionMessage")
    """Task failure error message"""

    payload = sgqlc.types.Field(sgqlc.types.non_null(JSONString), graphql_name="payload")
    """Task run payload"""

    associated_task = sgqlc.types.Field(AirflowTask, graphql_name="associatedTask")
    """task associated with the event"""

    urls = sgqlc.types.Field(AirflowUrls, graphql_name="urls")
    """URLs to Airflow UI"""

    task_mcon = sgqlc.types.Field(String, graphql_name="taskMcon")
    """MCON of Task for provided task_id"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of Job for provided job_id"""

    log_url = sgqlc.types.Field(String, graphql_name="logUrl")
    """Log URL for the Task Run"""

    attempts = sgqlc.types.Field(
        sgqlc.types.list_of(AirflowTaskRunAttempt), graphql_name="attempts"
    )
    """List of all retry attempts for this task run"""


class AlationIntegration(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "integration_name",
        "server_url",
        "username",
        "user_id",
        "dc_proxy",
        "disable_ssl_verification",
        "warehouse_datasource_mapping",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Integration external ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """Short text to describe the integration"""

    server_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="serverUrl")
    """Alation server URL"""

    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")
    """Alation username used to generate tokens"""

    user_id = sgqlc.types.Field(Int, graphql_name="userId")
    """Alation user ID. As returned by the authentication API, or as
    provided when using refresh token authentication.
    """

    dc_proxy = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="dcProxy")
    """Whether to proxy requests through DC"""

    disable_ssl_verification = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="disableSslVerification"
    )
    """Whether to disable SSL for DC proxy requests"""

    warehouse_datasource_mapping = sgqlc.types.Field(
        JSONString, graphql_name="warehouseDatasourceMapping"
    )
    """Mapping of MC warehouse UUID to Alation data source ID"""


class Alert(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = (
        "title",
        "reaction",
        "type",
        "sub_types",
        "owner",
        "severity",
        "priority",
        "status",
        "tables",
        "audiences",
        "monitor_tags",
        "invalid_rows",
        "domains",
        "comment_count",
        "jira_tickets",
        "service_now_incidents",
        "opsgenie_incidents",
        "datadog_incidents",
        "azure_devops_work_items",
        "created_time",
        "updated_time",
        "feedback",
        "name",
        "uuid",
        "url",
    )
    title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title")

    reaction = sgqlc.types.Field(AlertReaction, graphql_name="reaction")
    """(experimental) DEPRECATED. Feedback reaction associated with the
    alert
    """

    type = sgqlc.types.Field(sgqlc.types.non_null(AlertType), graphql_name="type")

    sub_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AlertSubType))),
        graphql_name="subTypes",
    )

    owner = sgqlc.types.Field(UserOutput, graphql_name="owner")

    severity = sgqlc.types.Field(Severity, graphql_name="severity")
    """Value is present if the alert has been marked as an incident"""

    priority = sgqlc.types.Field(Priority, graphql_name="priority")
    """Value is inherited from the associated monitor"""

    status = sgqlc.types.Field(AlertStatus, graphql_name="status")

    tables = sgqlc.types.Field(sgqlc.types.list_of(TableOutput), graphql_name="tables")
    """Tables or views associated with the alert"""

    audiences = sgqlc.types.Field(sgqlc.types.list_of(AudienceRef), graphql_name="audiences")
    """List of audiences associated with the alert"""

    monitor_tags = sgqlc.types.Field(
        sgqlc.types.list_of(TagKeyValuePairOutput), graphql_name="monitorTags"
    )
    """Monitor tags associated with the alert"""

    invalid_rows = sgqlc.types.Field(String, graphql_name="invalidRows")
    """Number of invalid rows of a breached monitor if available"""

    domains = sgqlc.types.Field(sgqlc.types.list_of(DomainRef), graphql_name="domains")
    """List of domain associated with the alert"""

    comment_count = sgqlc.types.Field(Int, graphql_name="commentCount")
    """Number of user comments associated with the alert"""

    jira_tickets = sgqlc.types.Field(sgqlc.types.list_of("JiraTicket"), graphql_name="jiraTickets")
    """Jira tickets associated with the alert"""

    service_now_incidents = sgqlc.types.Field(
        sgqlc.types.list_of("ServiceNowIncident"), graphql_name="serviceNowIncidents"
    )
    """ServiceNow incidents associated with the alert"""

    opsgenie_incidents = sgqlc.types.Field(
        sgqlc.types.list_of("OpsgenieIncident"), graphql_name="opsgenieIncidents"
    )
    """Opsgenie incidents associated with the alert"""

    datadog_incidents = sgqlc.types.Field(
        sgqlc.types.list_of("DatadogIncident"), graphql_name="datadogIncidents"
    )
    """Datadog incidents associated with the alert"""

    azure_devops_work_items = sgqlc.types.Field(
        sgqlc.types.list_of("AzureDevOpsWorkItem"), graphql_name="azureDevopsWorkItems"
    )
    """Azure DevOps work items associated with the alert"""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    feedback = sgqlc.types.Field(AlertStatus, graphql_name="feedback")
    """DEPRECATED. Use status instead"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """DEPRECATED. Use title instead"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """DEPRECATED. Use id instead"""

    url = sgqlc.types.Field(String, graphql_name="url")
    """URL of the alert"""


class AssetCollectionPreferences(sgqlc.types.Type, AssetCollectionPreferenceNode):
    """Describes assets with a defined metadata collection preference."""

    __schema__ = schema
    __field_names__ = (
        "account",
        "resource",
        "asset_type",
        "default_effect",
        "rules",
        "created_by",
        "created_time",
        "last_updated_by",
        "updated_time",
    )
    account = sgqlc.types.Field(Account, graphql_name="account")

    resource = sgqlc.types.Field("Resource", graphql_name="resource")

    asset_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="assetType")
    """The asset type that these collection preferences apply to"""

    default_effect = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionRuleEffect), graphql_name="defaultEffect"
    )
    """Whether to allow or block assets of this type when no rules match."""

    rules = sgqlc.types.Field(sgqlc.types.list_of(AssetCollectionRule), graphql_name="rules")
    """The set of rules for collection of this asset type."""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    last_updated_by = sgqlc.types.Field("User", graphql_name="lastUpdatedBy")

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")


class AssetFilterActivityRead(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("read_days",)
    read_days = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="readDays")


class AssetFilterActivityReadIsNull(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("read_activity_is_null",)
    read_activity_is_null = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="readActivityIsNull"
    )


class AssetFilterActivityReadWrite(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("read_write_days",)
    read_write_days = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="readWriteDays")


class AssetFilterActivityReadWriteIsNull(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("read_write_activity_is_null",)
    read_write_activity_is_null = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="readWriteActivityIsNull"
    )


class AssetFilterActivityVolumeChange(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("volume_change_days",)
    volume_change_days = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="volumeChangeDays"
    )


class AssetFilterActivityWrite(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("write_days",)
    write_days = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="writeDays")


class AssetFilterActivityWriteIsNull(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("write_activity_is_null",)
    write_activity_is_null = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="writeActivityIsNull"
    )


class AssetFilterTableName(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("table_name", "table_name_operator")
    table_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tableName")

    table_name_operator = sgqlc.types.Field(
        sgqlc.types.non_null(AssetFilterTableNameOperator), graphql_name="tableNameOperator"
    )


class AssetFilterTableTag(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("table_tags", "table_tags_operator")
    table_tags = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="tableTags",
    )

    table_tags_operator = sgqlc.types.Field(
        sgqlc.types.non_null(AssetFilterTableTagOperator), graphql_name="tableTagsOperator"
    )


class AssetFilterTableType(sgqlc.types.Type, AssetFilterInterface):
    __schema__ = schema
    __field_names__ = ("table_type",)
    table_type = sgqlc.types.Field(sgqlc.types.non_null(TableType), graphql_name="tableType")


class AudienceMonitor(sgqlc.types.Type, Node):
    """Backed by a UserDefinedMonitorModel, as returned by
    resolve_custom_monitors
    """

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "creator_id",
        "monitor_type",
        "name",
        "description",
        "audiences",
        "incident_count_history",
        "incident_count",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Unique identifier for monitors"""

    creator_id = sgqlc.types.Field(String, graphql_name="creatorId")
    """Email of user who created the monitor"""

    monitor_type = sgqlc.types.Field(
        sgqlc.types.non_null(UserDefinedMonitors), graphql_name="monitorType"
    )
    """Type of monitor"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Monitor name, default or user-defined"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Monitor description"""

    audiences = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="audiences")
    """List of audiences (labels) for the monitor"""

    incident_count_history = sgqlc.types.Field(
        sgqlc.types.list_of(NotificationIncidentDailyCount),
        graphql_name="incidentCountHistory",
        args=sgqlc.types.ArgDict(
            (("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),)
        ),
    )
    """Number of incidents per day for the past 30 days notified

    Arguments:

    * `audience_id` (`UUID`): filter by audience ID
    """

    incident_count = sgqlc.types.Field(
        sgqlc.types.non_null(Int),
        graphql_name="incidentCount",
        args=sgqlc.types.ArgDict(
            (("audience_id", sgqlc.types.Arg(UUID, graphql_name="audienceId", default=None)),)
        ),
    )
    """The number of distinct notified incidents in the past 30 days

    Arguments:

    * `audience_id` (`UUID`): filter by audience ID
    """


class AuditLogEntry(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "actor_name",
        "timestamp",
        "action",
        "changes",
        "object_type_name",
        "object_uuid",
        "actor_first_name",
        "actor_last_name",
    )
    actor_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="actorName")

    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")

    action = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="action")
    """create/update/delete"""

    changes = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(FieldChange)), graphql_name="changes"
    )
    """List of changes"""

    object_type_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="objectTypeName"
    )
    """Friendly name of object type"""

    object_uuid = sgqlc.types.Field(UUID, graphql_name="objectUuid")
    """Object UUID (if available)"""

    actor_first_name = sgqlc.types.Field(String, graphql_name="actorFirstName")
    """First name of the user who made the change"""

    actor_last_name = sgqlc.types.Field(String, graphql_name="actorLastName")
    """Last name of the user who made the change"""


class AuthUser(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "cognito_user_id",
        "email",
        "first_name",
        "last_name",
        "display_name",
        "state",
        "created_on",
        "is_sso",
        "sso_groups",
        "sso_groups_updated_at",
        "token_id",
        "is_deleted",
        "deleted_at",
        "deleted_by",
        "delete_reason",
        "invalidated_at",
        "persona",
        "streamingsystemmodel_created_by",
        "streamingsystemmodel_updated_by",
        "streamingclustermodel_created_by",
        "streamingclustermodel_updated_by",
        "monitor_labels_created",
        "routing_rules_created_by",
        "routing_rules_updated_by",
        "notification_settings_added",
        "notification_settings_modified",
        "user_model_deleted_by",
        "user_settings",
        "invitees",
        "warehouse_deleted_by",
        "created_warehouses",
        "warehousemodel_updated_by",
        "bicontainermodel_created_by",
        "bicontainermodel_updated_by",
        "etlcontainermodel_created_by",
        "etlcontainermodel_updated_by",
        "connectionmodel_created_by",
        "connectionmodel_updated_by",
        "eventmodel_set",
        "eventdetectorfeedbackmodel_created_by",
        "eventdetectorfeedbackmodel_updated_by",
        "customsqltemplatemodel_created_by",
        "customsqltemplatemodel_updated_by",
        "datasourcemodel_created_by",
        "datasourcemodel_updated_by",
        "creator",
        "metricmonitoringmodel_set",
        "customrulequerymodel_created_by",
        "customrulequerymodel_updated_by",
        "table_monitors_deleted_by",
        "tablemonitormodel_created_by",
        "tablemonitormodel_updated_by",
        "object_properties",
        "catalog_object_metadata",
        "resources",
        "monte_carlo_config_templates",
        "domain_created_by",
        "alationintegrationmodel_created_by",
        "alationintegrationmodel_updated_by",
        "slack_credentials_v2",
        "custom_users",
        "unified_users",
        "last_updated_unified_users",
        "collection_preference_created_by",
        "collection_preference_last_updated_by",
        "collection_preference_deleted_by",
        "asset_collection_preference_created_by",
        "asset_collection_preference_last_updated_by",
        "data_product_created_by",
        "data_product_last_updated_by",
        "data_product_deleted_by",
        "tutorial_user",
        "opsgenieintegrationmodel_created_by",
        "opsgenieintegrationmodel_updated_by",
        "collibra_integration_created_by",
        "collibraintegrationmodel_updated_by",
        "monitoredtablerulemodel_created_by",
        "monitoredtablerulemodel_updated_by",
        "customdashboardmodel_created_by",
        "customdashboardmodel_updated_by",
        "dataexplorerdashboardmodel_created_by",
        "dataexplorerdashboardmodel_updated_by",
        "dataexplorercomparisondashboardmodel_created_by",
        "dataexplorercomparisondashboardmodel_updated_by",
        "dataexplorerwidgetmodel_created_by",
        "dataexplorerwidgetmodel_updated_by",
        "lineage_block_patterns",
        "lineage_repl_rules",
        "lineagenodecollapsingpatternmodel_created_by",
        "lineagenodecollapsingpatternmodel_updated_by",
    )
    cognito_user_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cognitoUserId")

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")

    first_name = sgqlc.types.Field(String, graphql_name="firstName")

    last_name = sgqlc.types.Field(String, graphql_name="lastName")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Text to use when displaying the user."""

    state = sgqlc.types.Field(sgqlc.types.non_null(UserModelState), graphql_name="state")

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    is_sso = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSso")

    sso_groups = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="ssoGroups"
    )
    """Groups provided by the IdP in the last login"""

    sso_groups_updated_at = sgqlc.types.Field(DateTime, graphql_name="ssoGroupsUpdatedAt")
    """Last time the SSO groups where updated"""

    token_id = sgqlc.types.Field(String, graphql_name="tokenId")
    """For role=service accounts, the associated API token ID"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")
    """Timestamp the user was soft deleted at"""

    deleted_by = sgqlc.types.Field("User", graphql_name="deletedBy")

    delete_reason = sgqlc.types.Field(UserModelDeleteReason, graphql_name="deleteReason")
    """Reason the user was soft deleted"""

    invalidated_at = sgqlc.types.Field(DateTime, graphql_name="invalidatedAt")
    """Indicates if a user has been invalidated, and when the
    invalidation occurred
    """

    persona = sgqlc.types.Field(UserModelPersona, graphql_name="persona")
    """Each user has a persona that can help personalize the home page
    experience and the onboarding flow.
    """

    streamingsystemmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingSystem))),
        graphql_name="streamingsystemmodelCreatedBy",
    )
    """Creator"""

    streamingsystemmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingSystem))),
        graphql_name="streamingsystemmodelUpdatedBy",
    )
    """Last updated by"""

    streamingclustermodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingCluster))),
        graphql_name="streamingclustermodelCreatedBy",
    )
    """Creator"""

    streamingclustermodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingCluster))),
        graphql_name="streamingclustermodelUpdatedBy",
    )
    """Last updated by"""

    monitor_labels_created = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorLabelObject))),
        graphql_name="monitorLabelsCreated",
    )
    """Monitor label creator"""

    routing_rules_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationRoutingRule))),
        graphql_name="routingRulesCreatedBy",
    )
    """Creator of the routing rule"""

    routing_rules_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationRoutingRule))),
        graphql_name="routingRulesUpdatedBy",
    )
    """Routing rule last updated by"""

    notification_settings_added = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationSetting))),
        graphql_name="notificationSettingsAdded",
    )
    """Creator of the notification"""

    notification_settings_modified = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationSetting))),
        graphql_name="notificationSettingsModified",
    )
    """User who last updated this notification"""

    user_model_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(UserConnection),
        graphql_name="userModelDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("email", sgqlc.types.Arg(String, graphql_name="email", default=None)),
                ("first_name", sgqlc.types.Arg(String, graphql_name="firstName", default=None)),
                ("last_name", sgqlc.types.Arg(String, graphql_name="lastName", default=None)),
                ("role", sgqlc.types.Arg(String, graphql_name="role", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `email` (`String`)None
    * `first_name` (`String`)None
    * `last_name` (`String`)None
    * `role` (`String`)None
    """

    user_settings = sgqlc.types.Field(
        sgqlc.types.non_null(UserSettingsConnection),
        graphql_name="userSettings",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated user

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    invitees = sgqlc.types.Field(
        sgqlc.types.non_null(UserInviteConnection),
        graphql_name="invitees",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `state` (`String`)None
    """

    warehouse_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warehouse))),
        graphql_name="warehouseDeletedBy",
    )

    created_warehouses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warehouse))),
        graphql_name="createdWarehouses",
    )
    """User who created this warehouse"""

    warehousemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warehouse))),
        graphql_name="warehousemodelUpdatedBy",
    )
    """Last updated by"""

    bicontainermodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(BiContainer))),
        graphql_name="bicontainermodelCreatedBy",
    )
    """Creator"""

    bicontainermodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(BiContainer))),
        graphql_name="bicontainermodelUpdatedBy",
    )
    """Last updated by"""

    etlcontainermodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(EtlContainer))),
        graphql_name="etlcontainermodelCreatedBy",
    )
    """Creator"""

    etlcontainermodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(EtlContainer))),
        graphql_name="etlcontainermodelUpdatedBy",
    )
    """Last updated by"""

    connectionmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connectionmodelCreatedBy",
    )
    """Creator"""

    connectionmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connectionmodelUpdatedBy",
    )
    """Last updated by"""

    eventmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="eventmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    eventdetectorfeedbackmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(EventDetectorFeedbackConnection),
        graphql_name="eventdetectorfeedbackmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    eventdetectorfeedbackmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(EventDetectorFeedbackConnection),
        graphql_name="eventdetectorfeedbackmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    customsqltemplatemodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomSQLTemplateConnection),
        graphql_name="customsqltemplatemodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("sql_template", sgqlc.types.Arg(String, graphql_name="sqlTemplate", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        CustomSQLTemplateModelQueryResultType,
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `name` (`String`)None
    * `description` (`String`)None
    * `sql_template` (`String`)None
    * `dialect` (`String`)None
    * `query_result_type`
      (`CustomSQLTemplateModelQueryResultType`)None
    """

    customsqltemplatemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomSQLTemplateConnection),
        graphql_name="customsqltemplatemodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("sql_template", sgqlc.types.Arg(String, graphql_name="sqlTemplate", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        CustomSQLTemplateModelQueryResultType,
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `name` (`String`)None
    * `description` (`String`)None
    * `sql_template` (`String`)None
    * `dialect` (`String`)None
    * `query_result_type`
      (`CustomSQLTemplateModelQueryResultType`)None
    """

    datasourcemodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorDataSource))),
        graphql_name="datasourcemodelCreatedBy",
    )
    """Creator"""

    datasourcemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorDataSource))),
        graphql_name="datasourcemodelUpdatedBy",
    )
    """Last updated by"""

    creator = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonMonitorResponseConnection),
        graphql_name="creator",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Who added the monitor

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    metricmonitoringmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonMonitorResponseConnection),
        graphql_name="metricmonitoringmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Who was the last user to update the monitor

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    customrulequerymodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleQueryConnection),
        graphql_name="customrulequerymodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    customrulequerymodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleQueryConnection),
        graphql_name="customrulequerymodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    table_monitors_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(TableMonitorConnection),
        graphql_name="tableMonitorsDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Deleted by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tablemonitormodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(TableMonitorConnection),
        graphql_name="tablemonitormodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tablemonitormodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(TableMonitorConnection),
        graphql_name="tablemonitormodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    object_properties = sgqlc.types.Field(
        sgqlc.types.non_null(ObjectPropertyConnection),
        graphql_name="objectProperties",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("mcon_id", sgqlc.types.Arg(String, graphql_name="mconId", default=None)),
            )
        ),
    )
    """Who last updated the property

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `mcon_id` (`String`)None
    """

    catalog_object_metadata = sgqlc.types.Field(
        sgqlc.types.non_null(CatalogObjectMetadataConnection),
        graphql_name="catalogObjectMetadata",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
            )
        ),
    )
    """Who last updated the object

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `mcon` (`String`)None
    """

    resources = sgqlc.types.Field(
        sgqlc.types.non_null(ResourceConnection),
        graphql_name="resources",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Who last updated the resource

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    monte_carlo_config_templates = sgqlc.types.Field(
        sgqlc.types.non_null(MonteCarloConfigTemplateConnection),
        graphql_name="monteCarloConfigTemplates",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `namespace` (`String`)None
    """

    domain_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DomainRestrictionConnection),
        graphql_name="domainCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    alationintegrationmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(AlationIntegrationConnection),
        graphql_name="alationintegrationmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    alationintegrationmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(AlationIntegrationConnection),
        graphql_name="alationintegrationmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    slack_credentials_v2 = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(SlackCredentialsV2))),
        graphql_name="slackCredentialsV2",
    )
    """User that installed the Slack app"""

    custom_users = sgqlc.types.Field(
        sgqlc.types.non_null(CustomUserConnection),
        graphql_name="customUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Who last updated the object

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    unified_users = sgqlc.types.Field(
        sgqlc.types.non_null(UnifiedUserConnection),
        graphql_name="unifiedUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated MC user

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    last_updated_unified_users = sgqlc.types.Field(
        sgqlc.types.non_null(UnifiedUserConnection),
        graphql_name="lastUpdatedUnifiedUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Who last updated the object

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collection_preference_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferenceCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collection_preference_last_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferenceLastUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collection_preference_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferenceDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    asset_collection_preference_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionPreferencesConnection),
        graphql_name="assetCollectionPreferenceCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    asset_collection_preference_last_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionPreferencesConnection),
        graphql_name="assetCollectionPreferenceLastUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_last_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductLastUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tutorial_user = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UserTutorial))),
        graphql_name="tutorialUser",
    )
    """The user which the tutorial step is relevant for"""

    opsgenieintegrationmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(OpsgenieIntegrationOutput))),
        graphql_name="opsgenieintegrationmodelCreatedBy",
    )
    """Creator"""

    opsgenieintegrationmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(OpsgenieIntegrationOutput))),
        graphql_name="opsgenieintegrationmodelUpdatedBy",
    )
    """Last updated by"""

    collibra_integration_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollibraIntegrationConnection),
        graphql_name="collibraIntegrationCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collibraintegrationmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollibraIntegrationConnection),
        graphql_name="collibraintegrationmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    monitoredtablerulemodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitoredTableRuleObject))),
        graphql_name="monitoredtablerulemodelCreatedBy",
    )
    """Creator"""

    monitoredtablerulemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitoredTableRuleObject))),
        graphql_name="monitoredtablerulemodelUpdatedBy",
    )
    """Last updated by"""

    customdashboardmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardConnection),
        graphql_name="customdashboardmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    customdashboardmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardConnection),
        graphql_name="customdashboardmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerdashboardmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerDashboardTypeConnection),
        graphql_name="dataexplorerdashboardmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerdashboardmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerDashboardTypeConnection),
        graphql_name="dataexplorerdashboardmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorercomparisondashboardmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerComparisonDashboardTypeConnection),
        graphql_name="dataexplorercomparisondashboardmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorercomparisondashboardmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerComparisonDashboardTypeConnection),
        graphql_name="dataexplorercomparisondashboardmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerwidgetmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerWidgetTypeConnection),
        graphql_name="dataexplorerwidgetmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerwidgetmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerWidgetTypeConnection),
        graphql_name="dataexplorerwidgetmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    lineage_block_patterns = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeBlockPattern))),
        graphql_name="lineageBlockPatterns",
    )
    """Who last updated the regexp"""

    lineage_repl_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeReplacementRule))),
        graphql_name="lineageReplRules",
    )
    """Who last updated the replacement rule"""

    lineagenodecollapsingpatternmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeCollapsingRule))),
        graphql_name="lineagenodecollapsingpatternmodelCreatedBy",
    )
    """Creator"""

    lineagenodecollapsingpatternmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeCollapsingRule))),
        graphql_name="lineagenodecollapsingpatternmodelUpdatedBy",
    )
    """Last updated by"""


class AzureDevOpsWorkItem(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = (
        "project",
        "work_item_id",
        "work_item_type",
        "work_item_url",
        "created_at",
        "created_by",
        "integration_id",
        "originates_from_mc_notification",
    )
    project = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="project")
    """Azure DevOps project name where the work item was created"""

    work_item_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="workItemId")
    """Azure DevOps work item ID"""

    work_item_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="workItemType")
    """Work item type (Bug, Issue, Task, etc.)"""

    work_item_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="workItemUrl")
    """URL to the work item in Azure DevOps"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")

    created_by = sgqlc.types.Field(sgqlc.types.non_null(UserOutput), graphql_name="createdBy")

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Azure DevOps integration ID"""

    originates_from_mc_notification = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="originatesFromMcNotification"
    )


class CatalogObjectMetadata(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "mcon",
        "account_id",
        "resource_id",
        "description",
        "created_time",
        "last_update_user",
        "last_update_time",
        "source",
    )
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Customer resource id (e.g. warehouse)"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Markdown description of object"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the object was first created"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the object"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the object was last updated"""

    source = sgqlc.types.Field(String, graphql_name="source")
    """The source of this metadata (e.g. dbt, snowflake, bigquery, etc.)"""


class ChangeDataRca(sgqlc.types.Type, IBaseRca, IQueryRca):
    __schema__ = schema
    __field_names__ = ()


class CollectionBlock(sgqlc.types.Type, CollectionPreferenceNode):
    """Describes entities with a defined metadata collection preference."""

    __schema__ = schema
    __field_names__ = (
        "resource_id",
        "project",
        "dataset",
        "match_type",
        "target_object_type",
        "effect",
    )
    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """The resource UUID this collection block applies to."""

    project = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="project")
    """Top-level object hierarchy e.g. database, catalog, etc."""

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Intermediate object hierarchy e.g. schema, database, etc."""

    match_type = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionPreferenceMatchType), graphql_name="matchType"
    )
    """How entities are being matched."""

    target_object_type = sgqlc.types.Field(
        CollectionPreferenceTargetObjectType, graphql_name="targetObjectType"
    )
    """The type of object the rule applies to."""

    effect = sgqlc.types.Field(CollectionPreferenceEffectType, graphql_name="effect")
    """Whether the rule is to allow or block collection. Rules that allow
    collection overrides rules that block collection.
    """


class CollibraIntegration(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "last_update_user",
        "uuid",
        "integration_name",
        "server_url",
        "username",
        "created_time",
        "updated_time",
        "domain_uuid",
        "created_by",
        "warehouse_domain_mapping",
    )
    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Integration external ID"""

    integration_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="integrationName"
    )
    """Short text to describe the integration"""

    server_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="serverUrl")
    """Collibra server URL"""

    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")
    """Collibra username"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")

    domain_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="domainUuid")
    """Collibra integration domain UUID"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")

    warehouse_domain_mapping = sgqlc.types.Field(JSONString, graphql_name="warehouseDomainMapping")
    """Optional mapping of warehouse uuids to Collibra domain uuids"""


class ComparisonMonitorResponse(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "description",
        "notes",
        "namespace",
        "priority",
        "is_paused",
        "is_draft",
        "created_time",
        "monitor_name",
        "last_update_time",
        "source",
        "target",
        "monitor_type",
        "schedule_config",
        "notification_settings",
        "alert_conditions",
        "domain_uuids",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    description = sgqlc.types.Field(String, graphql_name="description")

    notes = sgqlc.types.Field(String, graphql_name="notes")

    namespace = sgqlc.types.Field(String, graphql_name="namespace")
    """Namespace of rule, used for monitors-as-code"""

    priority = sgqlc.types.Field(MetricMonitoringModelPriority, graphql_name="priority")
    """Default priority for alerts involving this monitor"""

    is_paused = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPaused")
    """Is this monitor paused?"""

    is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft")
    """Is this a draft monitor?"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the monitor was first created"""

    monitor_name = sgqlc.types.Field(String, graphql_name="monitorName")
    """Name of monitor, must be unique per account, used for rule
    identityresolution for monitors-as-code
    """

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the monitor was last updated"""

    source = sgqlc.types.Field(sgqlc.types.non_null(ExtendedDataSource), graphql_name="source")

    target = sgqlc.types.Field(sgqlc.types.non_null(ExtendedDataSource), graphql_name="target")

    monitor_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="monitorType")

    schedule_config = sgqlc.types.Field(
        sgqlc.types.non_null(ScheduleConfigOutput), graphql_name="scheduleConfig"
    )

    notification_settings = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AccountNotificationSetting))),
        graphql_name="notificationSettings",
    )

    alert_conditions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ComparisonAlertCondition))),
        graphql_name="alertConditions",
    )

    domain_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainUuids"
    )
    """Domain UUIDs assigned to the monitor."""


class ConnectionRestriction(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "deleted_at",
        "uuid",
        "type",
        "subtype",
        "name",
        "warehouse",
        "bi_container",
        "etl_container",
        "deletion_protection",
        "job_types",
        "streaming_cluster",
        "credentials_s3_key",
        "integration_gateway_credentials_key",
        "data",
        "created_on",
        "updated_on",
        "is_active",
        "disabled_on",
        "dbt_projects",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    type = sgqlc.types.Field(sgqlc.types.non_null(ConnectionModelType), graphql_name="type")

    subtype = sgqlc.types.Field(String, graphql_name="subtype")
    """Subtype of a plugin connection"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """Name of the connection"""

    warehouse = sgqlc.types.Field(Warehouse, graphql_name="warehouse")

    bi_container = sgqlc.types.Field(BiContainer, graphql_name="biContainer")

    etl_container = sgqlc.types.Field(EtlContainer, graphql_name="etlContainer")

    deletion_protection = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="deletionProtection"
    )
    """Prevents deletion when enabled."""

    job_types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="jobTypes",
    )

    streaming_cluster = sgqlc.types.Field(StreamingCluster, graphql_name="streamingCluster")

    credentials_s3_key = sgqlc.types.Field(String, graphql_name="credentialsS3Key")

    integration_gateway_credentials_key = sgqlc.types.Field(
        String, graphql_name="integrationGatewayCredentialsKey"
    )

    data = sgqlc.types.Field(JSONString, graphql_name="data")

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    updated_on = sgqlc.types.Field(DateTime, graphql_name="updatedOn")

    is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive")

    disabled_on = sgqlc.types.Field(DateTime, graphql_name="disabledOn")

    dbt_projects = sgqlc.types.Field(
        sgqlc.types.non_null(DbtProjectConnection),
        graphql_name="dbtProjects",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """dbt connection

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class CustomDashboard(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = ("dashboard_id", "title", "widgets")
    dashboard_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dashboardId")

    title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title")
    """The title of the dashboard"""

    widgets = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("CustomDashboardWidget"))),
        graphql_name="widgets",
    )
    """List of widgets"""


class CustomDashboardList(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = ("dashboard_id", "title")
    dashboard_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="dashboardId")

    title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title")
    """The title of the dashboard"""


class CustomDashboardWidget(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "widget_id",
        "type",
        "title",
        "order",
        "width",
        "height",
        "data_sources",
        "options",
    )
    widget_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="widgetId")

    type = sgqlc.types.Field(sgqlc.types.non_null(CustomDashboardWidgetType), graphql_name="type")
    """Type of the widget"""

    title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title")
    """Title of the widget"""

    order = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="order")
    """Order of the widget inside the dashboard"""

    width = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="width")
    """Width of the widget inside the dashboard"""

    height = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="height")
    """Height of the widget inside the dashboard"""

    data_sources = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(WidgetDataSourceInterface)),
        graphql_name="dataSources",
    )
    """Data source definitions"""

    options = sgqlc.types.Field(WidgetOptionsInterface, graphql_name="options")
    """Widget specific options"""


class CustomRule(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_uuid",
        "projects",
        "datasets",
        "is_deleted",
        "deleted_at",
        "description",
        "notes",
        "labels",
        "failure_audiences",
        "is_template_managed",
        "namespace",
        "severity",
        "priority",
        "comparisons",
        "is_paused",
        "is_draft",
        "rule_type",
        "warehouse_uuid",
        "interval_minutes",
        "interval_crontab",
        "start_time",
        "timezone",
        "creator_id",
        "updater_id",
        "prev_execution_time",
        "next_execution_time",
        "last_check_timestamp",
        "snooze_until_time",
        "slack_snooze_user",
        "conditional_snooze",
        "event_rollup_until_changed",
        "event_rollup_count",
        "schedule",
        "dc_schedule_uuid",
        "data_collection_dc_schedule_uuid",
        "custom_sql",
        "override",
        "fields",
        "generated_by",
        "entities",
        "data_source",
        "rule_name",
        "sequence_number",
        "system_snooze_until_time",
        "query_result_type",
        "custom_sampling_sql",
        "sql_blocks",
        "generated_rules",
        "queries",
        "entity_mcons",
        "rendered_custom_sql",
        "schedule_config",
        "data_collection_schedule_config",
        "notification_settings",
        "is_snoozed",
        "migrated_to_uuid",
        "field_metric",
        "field_query_parameters",
        "query_template_id",
        "query_template_variable_values",
        "suggested_custom_sampling_sql",
        "selection",
        "is_ootb_replacement",
        "is_migrated_from_field_quality",
        "connection_id",
        "timeout",
        "mc_sql",
        "tags",
        "data_quality_dimension",
        "domain_uuids",
        "notify_rule_run_failure",
        "variables",
        "variable_definitions",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    account_uuid = sgqlc.types.Field(UUID, graphql_name="accountUuid")
    """Customer account id"""

    projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="projects"
    )
    """Databases associated with the monitor"""

    datasets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="datasets"
    )
    """Schemas associated with the monitor"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    description = sgqlc.types.Field(String, graphql_name="description")

    notes = sgqlc.types.Field(String, graphql_name="notes")

    labels = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="labels")
    """Monitor labels"""

    failure_audiences = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="failureAudiences"
    )
    """The monitor notification audiences for failures"""

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )
    """Is this monitor managed by a configuration template (monitors-as-
    code)?
    """

    namespace = sgqlc.types.Field(String, graphql_name="namespace")
    """Namespace of rule, used for monitors-as-code"""

    severity = sgqlc.types.Field(String, graphql_name="severity")
    """DEPRECATED. Use priority instead. The default severity for
    incidents involving this monitor
    """

    priority = sgqlc.types.Field(String, graphql_name="priority")
    """The default priority for alerts involving this monitor"""

    comparisons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparison)), graphql_name="comparisons"
    )

    is_paused = sgqlc.types.Field(Boolean, graphql_name="isPaused")
    """True if rule is paused"""

    is_draft = sgqlc.types.Field(Boolean, graphql_name="isDraft")
    """True if rule is a draft"""

    rule_type = sgqlc.types.Field(CustomRuleModelRuleType, graphql_name="ruleType")

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")

    interval_crontab = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="intervalCrontab"
    )

    start_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startTime")

    timezone = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timezone")

    creator_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="creatorId")
    """The email of the user that created the monitor"""

    updater_id = sgqlc.types.Field(String, graphql_name="updaterId")
    """The email of the user that last updated the monitor"""

    prev_execution_time = sgqlc.types.Field(DateTime, graphql_name="prevExecutionTime")

    next_execution_time = sgqlc.types.Field(DateTime, graphql_name="nextExecutionTime")

    last_check_timestamp = sgqlc.types.Field(DateTime, graphql_name="lastCheckTimestamp")

    snooze_until_time = sgqlc.types.Field(DateTime, graphql_name="snoozeUntilTime")

    slack_snooze_user = sgqlc.types.Field(String, graphql_name="slackSnoozeUser")
    """The slack user who last snoozed the rule"""

    conditional_snooze = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="conditionalSnooze"
    )

    event_rollup_until_changed = sgqlc.types.Field(Boolean, graphql_name="eventRollupUntilChanged")
    """If true, roll up events until the condition changes"""

    event_rollup_count = sgqlc.types.Field(Int, graphql_name="eventRollupCount")
    """The number of events to roll up into a single incident"""

    schedule = sgqlc.types.Field(DataCollectorSchedule, graphql_name="schedule")

    dc_schedule_uuid = sgqlc.types.Field(UUID, graphql_name="dcScheduleUuid")

    data_collection_dc_schedule_uuid = sgqlc.types.Field(
        UUID, graphql_name="dataCollectionDcScheduleUuid"
    )

    custom_sql = sgqlc.types.Field(String, graphql_name="customSql")

    override = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="override")

    fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fields"
    )
    """Fields used in predefined SQL rules"""

    generated_by = sgqlc.types.Field("CustomRule", graphql_name="generatedBy")

    entities = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entities"
    )
    """Tables referenced in query"""

    data_source = sgqlc.types.Field(MonitorDataSource, graphql_name="dataSource")

    rule_name = sgqlc.types.Field(String, graphql_name="ruleName")
    """Name of rule, must be unique per account, used for rule
    identityresolution for monitors-as-code
    """

    sequence_number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="sequenceNumber")
    """Last sequence number, used by growth volume SLIs"""

    system_snooze_until_time = sgqlc.types.Field(DateTime, graphql_name="systemSnoozeUntilTime")
    """Snoozes rule execution, but not available to users as
    snooze_until_time
    """

    query_result_type = sgqlc.types.Field(
        CustomRuleModelQueryResultType, graphql_name="queryResultType"
    )
    """Specifies the expected result type of the custom SQL query (e.g. a
    single numeric value). The null value will default to row count
    """

    custom_sampling_sql = sgqlc.types.Field(String, graphql_name="customSamplingSql")
    """Custom query to sample the data on breach"""

    sql_blocks = sgqlc.types.Field(CustomRuleSqlBlocks, graphql_name="sqlBlocks")
    """SQL blocks used on the monitor"""

    generated_rules = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleConnection),
        graphql_name="generatedRules",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "rule_type",
                    sgqlc.types.Arg(CustomRuleModelRuleType, graphql_name="ruleType", default=None),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `rule_type` (`CustomRuleModelRuleType`)None
    * `warehouse_uuid` (`UUID`)None
    """

    queries = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleQueryConnection),
        graphql_name="queries",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    entity_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="entityMcons")
    """MCONs for monitored tables/views"""

    rendered_custom_sql = sgqlc.types.Field(String, graphql_name="renderedCustomSql")

    schedule_config = sgqlc.types.Field(ScheduleConfigOutput, graphql_name="scheduleConfig")

    data_collection_schedule_config = sgqlc.types.Field(
        ScheduleConfigOutput, graphql_name="dataCollectionScheduleConfig"
    )

    notification_settings = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AccountNotificationSetting))),
        graphql_name="notificationSettings",
    )

    is_snoozed = sgqlc.types.Field(Boolean, graphql_name="isSnoozed")
    """True if rule is currently snoozed"""

    migrated_to_uuid = sgqlc.types.Field(UUID, graphql_name="migratedToUuid")
    """UUID of the rule this was migrated to, if applicable"""

    field_metric = sgqlc.types.Field(FieldMetricOutput, graphql_name="fieldMetric")
    """Field quality rule parameters (if query generated by
    getFieldMetricQuery)
    """

    field_query_parameters = sgqlc.types.Field(
        FieldQueryParametersOutput, graphql_name="fieldQueryParameters"
    )
    """Field query parameters (if query generated by getFieldQuery)"""

    query_template_id = sgqlc.types.Field(String, graphql_name="queryTemplateId")
    """Query template ID (if query generated by getQueryTemplate)"""

    query_template_variable_values = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(QueryTemplateVariableValueOutput)),
        graphql_name="queryTemplateVariableValues",
    )
    """Values for the template variables (if query generated by
    getQueryTemplate).
    """

    suggested_custom_sampling_sql = sgqlc.types.Field(
        String, graphql_name="suggestedCustomSamplingSql"
    )
    """A suggested investigation query for this rule based on ML model"""

    selection = sgqlc.types.Field(QuerySelection, graphql_name="selection")
    """Selection of the monitored queries"""

    is_ootb_replacement = sgqlc.types.Field(Boolean, graphql_name="isOotbReplacement")
    """Indicate if this rule replaces the default ootb detector"""

    is_migrated_from_field_quality = sgqlc.types.Field(
        Boolean, graphql_name="isMigratedFromFieldQuality"
    )
    """Indicate if the monitor was migrated from a field quality (metrics
    legacy) rule
    """

    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """The connection UUID associated with the rule"""

    timeout = sgqlc.types.Field(Int, graphql_name="timeout")
    """Timeout for the SQL query"""

    mc_sql = sgqlc.types.Field(String, graphql_name="mcSql")
    """SQL query for the monitor"""

    tags = sgqlc.types.Field(sgqlc.types.list_of(TagKeyValuePairOutput), graphql_name="tags")
    """The monitor tags."""

    data_quality_dimension = sgqlc.types.Field(String, graphql_name="dataQualityDimension")
    """Data Quality Dimension of the monitor."""

    domain_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainUuids"
    )
    """Domain UUIDs assigned to the monitor."""

    notify_rule_run_failure = sgqlc.types.Field(Boolean, graphql_name="notifyRuleRunFailure")
    """DEPRECATED: Replaced by failure audiences"""

    variables = sgqlc.types.Field(JSONString, graphql_name="variables")
    """Variables for the query"""

    variable_definitions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(VariableDefinition)),
        graphql_name="variableDefinitions",
    )
    """Variables definitions used in the query"""


class CustomRuleQuery(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "name",
        "sql_query",
        "warehouse_uuid",
        "connection_uuid",
        "projects",
        "datasets",
        "entities",
        "entity_mcons",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Query name"""

    sql_query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlQuery")
    """SQL query text"""

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")
    """Warehouse to query"""

    connection_uuid = sgqlc.types.Field(UUID, graphql_name="connectionUuid")
    """Connection to use for query. Supports multi-query engine setups
    (vs. lookup from warehouse).
    """

    projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="projects"
    )
    """Projects associated with the query"""

    datasets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="datasets"
    )
    """Datasets associated with the query"""

    entities = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entities"
    )
    """Tables referenced in query"""

    entity_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entityMcons"
    )
    """MCONs for tables referenced in query"""


class CustomSQLTemplate(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "name",
        "dialect",
        "description",
        "sql_template",
        "query_result_type",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Name of template, must be unique per account"""

    dialect = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dialect")

    description = sgqlc.types.Field(String, graphql_name="description")

    sql_template = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sqlTemplate")

    query_result_type = sgqlc.types.Field(
        CustomSQLTemplateModelQueryResultType, graphql_name="queryResultType"
    )
    """Specifies the expected result type of the custom SQL query (e.g. a
    single numeric value). The null value will default to row count
    """


class CustomUser(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "account_id",
        "email",
        "first_name",
        "last_name",
        "created_time",
        "last_update_user",
        "last_update_time",
        "is_deleted",
        "unified_users",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of custom user"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    email = sgqlc.types.Field(String, graphql_name="email")
    """Email"""

    first_name = sgqlc.types.Field(String, graphql_name="firstName")
    """First name"""

    last_name = sgqlc.types.Field(String, graphql_name="lastName")
    """Last name"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the object was first created"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the object"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the object was last updated"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    unified_users = sgqlc.types.Field(
        sgqlc.types.non_null(UnifiedUserConnection),
        graphql_name="unifiedUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated custom user

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DataExplorerComparisonDashboardType(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "account",
        "name",
        "dashboard_left",
        "dashboard_right",
        "criteria",
        "widgets",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Friendly name for dashboard"""

    dashboard_left = sgqlc.types.Field(
        sgqlc.types.non_null("DataExplorerDashboardType"), graphql_name="dashboardLeft"
    )

    dashboard_right = sgqlc.types.Field(
        sgqlc.types.non_null("DataExplorerDashboardType"), graphql_name="dashboardRight"
    )

    criteria = sgqlc.types.Field(JSONString, graphql_name="criteria")
    """Saved filtering criteria"""

    widgets = sgqlc.types.Field(
        DataExplorerWidgetTypeConnection,
        graphql_name="widgets",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DataExplorerDashboardType(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "account",
        "warehouse",
        "name",
        "mcon",
        "time_axis_field_name",
        "base_where_clause",
        "criteria",
        "comparison_dashboards_left",
        "comparison_dashboards_right",
        "widgets",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")

    name = sgqlc.types.Field(String, graphql_name="name")
    """Friendly name for dashboard"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    time_axis_field_name = sgqlc.types.Field(String, graphql_name="timeAxisFieldName")
    """Name of time axis field"""

    base_where_clause = sgqlc.types.Field(String, graphql_name="baseWhereClause")
    """Base where clause"""

    criteria = sgqlc.types.Field(sgqlc.types.non_null(JSONString), graphql_name="criteria")
    """Saved filtering criteria"""

    comparison_dashboards_left = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerComparisonDashboardTypeConnection),
        graphql_name="comparisonDashboardsLeft",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    comparison_dashboards_right = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerComparisonDashboardTypeConnection),
        graphql_name="comparisonDashboardsRight",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    widgets = sgqlc.types.Field(
        DataExplorerWidgetTypeConnection,
        graphql_name="widgets",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DataExplorerWidgetType(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "account",
        "field_name",
        "widget_type",
        "dashboard",
        "comparison_dashboard",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    field_name = sgqlc.types.Field(String, graphql_name="fieldName")
    """Field associated with widget"""

    widget_type = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerWidgetModelWidgetType), graphql_name="widgetType"
    )
    """Widget type"""

    dashboard = sgqlc.types.Field(DataExplorerDashboardType, graphql_name="dashboard")

    comparison_dashboard = sgqlc.types.Field(
        DataExplorerComparisonDashboardType, graphql_name="comparisonDashboard"
    )


class DataProduct(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "name",
        "created_in_domain",
        "account",
        "description",
        "created_by",
        "last_updated_by",
        "is_deleted",
        "deleted_at",
        "deleted_by",
        "shared_with_all_in_same_account",
        "assets",
        "data_product_tag",
        "warehouse_uuids",
        "table_count",
        "monitored_table_count",
        "unmonitored_table_count",
        "excluded_table_count",
        "monitored",
        "audiences",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """The data product id"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """User defined data product name."""

    created_in_domain = sgqlc.types.Field("DomainRestriction", graphql_name="createdInDomain")
    """Related data product created in a domain"""

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    description = sgqlc.types.Field(String, graphql_name="description")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")

    last_updated_by = sgqlc.types.Field("User", graphql_name="lastUpdatedBy")

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")
    """Flag to indicate whether this entry is in use or not."""

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    deleted_by = sgqlc.types.Field("User", graphql_name="deletedBy")

    shared_with_all_in_same_account = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="sharedWithAllInSameAccount"
    )
    """Flag to indicate whether this data product is shared with all
    users in the same account. When it is not shared it should have a
    false value.
    """

    assets = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductAssetConnection),
        graphql_name="assets",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Data product an asset belongs to

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_tag = sgqlc.types.Field(String, graphql_name="dataProductTag")
    """Tag created automatically for all assets included in the data
    product.
    """

    warehouse_uuids = sgqlc.types.Field(sgqlc.types.list_of(UUID), graphql_name="warehouseUuids")
    """Warehouse uuids of tables tagged in this data product"""

    table_count = sgqlc.types.Field(Int, graphql_name="tableCount")
    """Number of table type resources included in the data product"""

    monitored_table_count = sgqlc.types.Field(Int, graphql_name="monitoredTableCount")
    """Number of tables that are monitored in the data product"""

    unmonitored_table_count = sgqlc.types.Field(Int, graphql_name="unmonitoredTableCount")
    """Number of tables that are not being monitored in the data product"""

    excluded_table_count = sgqlc.types.Field(Int, graphql_name="excludedTableCount")
    """Number of tables that are not being monitored in the data product"""

    monitored = sgqlc.types.Field(Boolean, graphql_name="monitored")
    """Whether monitoring rules"""

    audiences = sgqlc.types.Field(
        sgqlc.types.list_of(NotificationAudience), graphql_name="audiences"
    )
    """List of audiences for this data product"""


class DataProductAsset(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "data_product",
        "mcon",
        "deleted_mcon_display_name",
        "object_type",
        "display_name",
        "table_id",
        "is_deleted",
        "is_visible_in_domain",
        "categories_with_monitors",
        "incidents",
        "upstream_dependencies_count",
        "upstream_dependencies_excluded_in_domain",
        "upstream_categories_with_monitors",
        "upstream_incidents",
        "shared_dependencies_count",
        "table_capabilities",
        "importance_score",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    data_product = sgqlc.types.Field(sgqlc.types.non_null(DataProduct), graphql_name="dataProduct")
    """Data product an asset belongs to"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """The asset MC unique identifier"""

    deleted_mcon_display_name = sgqlc.types.Field(String, graphql_name="deletedMconDisplayName")
    """A display name for this asset. The redundancy is loaded for
    deleted catalog objects.
    """

    object_type = sgqlc.types.Field(String, graphql_name="objectType")
    """Object type of the asset"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Display name of the asset"""

    table_id = sgqlc.types.Field(String, graphql_name="tableId")
    """Table identifier if it is a table"""

    is_deleted = sgqlc.types.Field(Boolean, graphql_name="isDeleted")
    """Indicates if the asset was deleted"""

    is_visible_in_domain = sgqlc.types.Field(Boolean, graphql_name="isVisibleInDomain")
    """Indicates if the asset is visible in the selected domain"""

    categories_with_monitors = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentCategory), graphql_name="categoriesWithMonitors"
    )
    """Categories that have at least one monitor set up"""

    incidents = sgqlc.types.Field(
        sgqlc.types.list_of(WarehouseTableIncident),
        graphql_name="incidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "limit_per_category",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="limitPerCategory", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="categories",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Incidents associated with the table

    Arguments:

    * `limit_per_category` (`Int!`): Maximum number of incidents per
      category
    * `start_time` (`DateTime!`): Filter incidents newer than this
    * `end_time` (`DateTime`): Filter incidents older than this
    * `include_feedback` (`[String]`): Filter incidents by user
      feedback
    * `exclude_feedback` (`[String]`): Exclude incidents by user
      feedback
    * `include_normalized` (`Boolean`): If false, filter out
      normalized incidents.
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `categories` (`[IncidentCategory]`): Include only selected
      incident categories. Or all categories if not specified.
    """

    upstream_dependencies_count = sgqlc.types.Field(Int, graphql_name="upstreamDependenciesCount")
    """Number of tables in upstream dependencies (up to the selected
    number of levels)
    """

    upstream_dependencies_excluded_in_domain = sgqlc.types.Field(
        Int, graphql_name="upstreamDependenciesExcludedInDomain"
    )
    """Number of tables in upstream dependencies that are not visible in
    the selected domain
    """

    upstream_categories_with_monitors = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentCategory), graphql_name="upstreamCategoriesWithMonitors"
    )
    """Categories that have at least one monitor set up in upstream
    dependencies
    """

    upstream_incidents = sgqlc.types.Field(
        sgqlc.types.list_of(WarehouseTableIncident),
        graphql_name="upstreamIncidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "limit_per_category",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="limitPerCategory", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="categories",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Incidents associated to upstream dependencies

    Arguments:

    * `limit_per_category` (`Int!`): Maximum number of incidents per
      category
    * `start_time` (`DateTime!`): Filter incidents newer than this
    * `end_time` (`DateTime`): Filter incidents older than this
    * `include_feedback` (`[String]`): Filter incidents by user
      feedback
    * `exclude_feedback` (`[String]`): Exclude incidents by user
      feedback
    * `include_normalized` (`Boolean`): If false, filter out
      normalized incidents.
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `categories` (`[IncidentCategory]`): Include only selected
      incident categories. Or all categories if not specified.
    """

    shared_dependencies_count = sgqlc.types.Field(Int, graphql_name="sharedDependenciesCount")
    """Number of dependencies that are shared with other assets, it
    includes the asset and upstream dependencies
    """

    table_capabilities = sgqlc.types.Field(
        TableCapabilitiesResponse, graphql_name="tableCapabilities"
    )
    """Capabilities for the table"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")
    """The table importance score (0-1)"""


class DataSourceInputSql(sgqlc.types.Type, DataSourceInputInterface):
    __schema__ = schema
    __field_names__ = ("sql", "transforms")
    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")
    """The SQL query that defines the source of the data"""

    transforms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Transform)), graphql_name="transforms"
    )


class DataSourceInputTable(sgqlc.types.Type, DataSourceInputInterface):
    __schema__ = schema
    __field_names__ = ("mcon", "transforms")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    transforms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Transform)), graphql_name="transforms"
    )


class DataSourceSql(sgqlc.types.Type, DataSourceInterface):
    __schema__ = schema
    __field_names__ = ("sql", "transforms")
    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")
    """The SQL query that defines the source of the data"""

    transforms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Transform)), graphql_name="transforms"
    )


class DataSourceTable(sgqlc.types.Type, DataSourceInterface):
    __schema__ = schema
    __field_names__ = ("mcon", "transforms")
    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    transforms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Transform)), graphql_name="transforms"
    )


class DatabricksJob(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "account",
        "generates_incidents",
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "mcon",
        "job_id",
        "job_name",
        "job_description",
        "settings",
        "change_time",
        "delete_time",
        "creator",
        "run_as",
        "workspace_id",
        "last_run_date",
        "last_webhook_received",
        "runs",
        "etl_type",
        "source_tables",
        "dest_tables",
        "recent_run_count",
        "generates_alerts",
        "tasks",
        "job_url",
        "webhook_status",
    )
    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    generates_incidents = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesIncidents"
    )

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the pipeline"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Job ID"""

    job_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobName")
    """Job Name"""

    job_description = sgqlc.types.Field(String, graphql_name="jobDescription")
    """Job Description"""

    settings = sgqlc.types.Field(JSONString, graphql_name="settings")
    """Databricks Job settings"""

    change_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="changeTime")
    """Time when job was last modified"""

    delete_time = sgqlc.types.Field(DateTime, graphql_name="deleteTime")
    """Time when job was deleted"""

    creator = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="creator")
    """User who created the job"""

    run_as = sgqlc.types.Field(String, graphql_name="runAs")
    """User used to run the job"""

    workspace_id = sgqlc.types.Field(String, graphql_name="workspaceId")
    """Databricks Workspace where the job exists"""

    last_run_date = sgqlc.types.Field(DateTime, graphql_name="lastRunDate")
    """The date of the last run"""

    last_webhook_received = sgqlc.types.Field(DateTime, graphql_name="lastWebhookReceived")
    """Timestamp of the last webhook event received for this job"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksJobRunConnection),
        graphql_name="runs",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Job associated with the run

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    etl_type = sgqlc.types.Field(sgqlc.types.non_null(EtlType), graphql_name="etlType")
    """Etl type of the job"""

    source_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="sourceTables"
    )
    """Tables read from in this job"""

    dest_tables = sgqlc.types.Field(
        sgqlc.types.list_of("WarehouseTable"), graphql_name="destTables"
    )
    """Tables modified in this job"""

    recent_run_count = sgqlc.types.Field(Int, graphql_name="recentRunCount")
    """Number of runs of this job within the last 30 days"""

    generates_alerts = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts"
    )
    """Whether this job generates alerts when it fails"""

    tasks = sgqlc.types.Field(sgqlc.types.list_of("DatabricksTask"), graphql_name="tasks")
    """Tasks in this job"""

    job_url = sgqlc.types.Field(String, graphql_name="jobUrl")
    """Url of the job page in the original Databricks environment"""

    webhook_status = sgqlc.types.Field(WebhookStatus, graphql_name="webhookStatus")
    """Webhook status info for this job"""


class DatabricksJobRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "success",
        "job_id",
        "run_id",
        "started_at",
        "finished_at",
        "compute_ids",
        "termination_code",
        "status",
        "trigger_type",
        "run_type",
        "run_name",
        "job_parameters",
        "run_url",
        "associated_job",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the event"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """run was successful or not"""

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Job ID"""

    run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="runId")
    """Run ID"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Time the run started. 'period_start_time' in Databricks"""

    finished_at = sgqlc.types.Field(DateTime, graphql_name="finishedAt")
    """Time the run ended. 'period_end_time' in Databricks"""

    compute_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="computeIds"
    )
    """The ids of the compute for this task run"""

    termination_code = sgqlc.types.Field(String, graphql_name="terminationCode")
    """termination code for the run"""

    status = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksJobRunModelStatus), graphql_name="status"
    )
    """Final status of the run. 'result_state' in Databricks"""

    trigger_type = sgqlc.types.Field(String, graphql_name="triggerType")
    """trigger type for the job"""

    run_type = sgqlc.types.Field(String, graphql_name="runType")
    """run type for the job"""

    run_name = sgqlc.types.Field(String, graphql_name="runName")
    """run name for the job run"""

    job_parameters = sgqlc.types.Field(JSONString, graphql_name="jobParameters")
    """Databricks Job Run parameters"""

    run_url = sgqlc.types.Field(String, graphql_name="runUrl")
    """Url of the run page in the original Databricks environment"""

    associated_job = sgqlc.types.Field(DatabricksJob, graphql_name="associatedJob")
    """Job associated with the run"""


class DatabricksTask(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "account",
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "mcon",
        "dbx_job_id",
        "task_id",
        "change_time",
        "delete_time",
        "depends_on",
        "runs",
    )
    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the pipeline"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    dbx_job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dbxJobId")
    """Job ID"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID"""

    change_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="changeTime")
    """Time when task was last modified"""

    delete_time = sgqlc.types.Field(DateTime, graphql_name="deleteTime")
    """Time when task was deleted"""

    depends_on = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="dependsOn"
    )
    """The task ids of the upstream dependencies for this task"""

    runs = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksTaskRunConnection),
        graphql_name="runs",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Task associated with the run

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DatabricksTaskRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "resource",
        "success",
        "job_id",
        "run_id",
        "started_at",
        "finished_at",
        "compute_ids",
        "termination_code",
        "status",
        "job_run_id",
        "task_id",
        "associated_task",
        "task_mcon",
        "job_mcon",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of Run"""

    resource = sgqlc.types.Field(sgqlc.types.non_null(EtlContainer), graphql_name="resource")
    """ETL container associated with the event"""

    success = sgqlc.types.Field(Boolean, graphql_name="success")
    """run was successful or not"""

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Job ID"""

    run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="runId")
    """Run ID"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Time the run started. 'period_start_time' in Databricks"""

    finished_at = sgqlc.types.Field(DateTime, graphql_name="finishedAt")
    """Time the run ended. 'period_end_time' in Databricks"""

    compute_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="computeIds"
    )
    """The ids of the compute for this task run"""

    termination_code = sgqlc.types.Field(String, graphql_name="terminationCode")
    """termination code for the run"""

    status = sgqlc.types.Field(
        sgqlc.types.non_null(DatabricksTaskRunModelStatus), graphql_name="status"
    )
    """Final status of the run. 'result_state' in Databricks"""

    job_run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobRunId")
    """Job Run ID"""

    task_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="taskId")
    """Task ID"""

    associated_task = sgqlc.types.Field(DatabricksTask, graphql_name="associatedTask")
    """Task associated with the run"""

    task_mcon = sgqlc.types.Field(String, graphql_name="taskMcon")
    """MCON of Task for provided task_id"""

    job_mcon = sgqlc.types.Field(String, graphql_name="jobMcon")
    """MCON of Job for provided job_id"""


class DatadogIncident(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = (
        "created_by",
        "dd_incident_id",
        "dd_public_id",
        "incident_title",
        "display_name",
        "incident_url",
        "integration_id",
        "created_at",
    )
    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    dd_incident_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ddIncidentId")
    """Datadog internal incident identifier"""

    dd_public_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ddPublicId")
    """Datadog public incident identifier"""

    incident_title = sgqlc.types.Field(String, graphql_name="incidentTitle")
    """Incident title captured at creation time"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")

    incident_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="incidentUrl")
    """Datadog incident URL"""

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Datadog integration ID"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")


class Dataset(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "deleted_at",
        "uuid",
        "warehouse",
        "project",
        "dataset",
        "mcon",
        "created_at",
        "updated_at",
        "is_excluded",
        "is_muted",
        "table_count",
        "muted_event_types",
    )
    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")

    project = sgqlc.types.Field(String, graphql_name="project")

    dataset = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dataset")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """Timestamp of when a schema (dataset) is created."""

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")
    """Timestamp of when a schema (dataset) is updated."""

    is_excluded = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExcluded")

    is_muted = sgqlc.types.Field(Boolean, graphql_name="isMuted")
    """No incidents will be created for this table if muted."""

    table_count = sgqlc.types.Field(Int, graphql_name="tableCount")
    """Number of tables in the dataset"""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Muting is active for the specified event types."""


class DbtEdge(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "source_unique_id",
        "destination_unique_id",
        "dbt_project",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt project"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    source_unique_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="sourceUniqueId"
    )
    """source dbt unique ID"""

    destination_unique_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="destinationUniqueId"
    )
    """destination dbt unique ID"""

    dbt_project = sgqlc.types.Field(sgqlc.types.non_null("DbtProject"), graphql_name="dbtProject")
    """Associated dbt project"""


class DbtJob(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "job_id",
        "job_name",
        "dbt_project",
        "generates_incidents",
        "mcon",
        "last_run_date",
        "last_webhook_received",
        "dbt_job_executions",
        "dbt_runs",
        "generates_alerts",
        "job_url",
        "etl_type",
        "recent_run_count",
        "webhook_status",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt job"""

    job_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobId")
    """Id of the job if dbt-cloud, if it is dbt-core it will be the same
    as jobName
    """

    job_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="jobName")
    """dbt job name"""

    dbt_project = sgqlc.types.Field(sgqlc.types.non_null("DbtProject"), graphql_name="dbtProject")
    """Associated dbt project"""

    generates_incidents = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesIncidents"
    )

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")
    """MCON of the job"""

    last_run_date = sgqlc.types.Field(DateTime, graphql_name="lastRunDate")
    """The date of the last run we know about"""

    last_webhook_received = sgqlc.types.Field(DateTime, graphql_name="lastWebhookReceived")
    """Timestamp of the last webhook event received for this job"""

    dbt_job_executions = sgqlc.types.Field(
        sgqlc.types.non_null(DbtJobExecutionConnection),
        graphql_name="dbtJobExecutions",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """dbt job that was executed

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dbt_runs = sgqlc.types.Field(
        sgqlc.types.non_null(DbtRunConnection),
        graphql_name="dbtRuns",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated dbt job

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    generates_alerts = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="generatesAlerts"
    )
    """Whether this job generates alerts or not"""

    job_url = sgqlc.types.Field(String, graphql_name="jobUrl")
    """Url of the dbt cloud environment. For dbt-core jobs it will be
    null.
    """

    etl_type = sgqlc.types.Field(sgqlc.types.non_null(EtlType), graphql_name="etlType")
    """Etl type of the job"""

    recent_run_count = sgqlc.types.Field(Int, graphql_name="recentRunCount")
    """Number of runs of this job within the last 30 days"""

    webhook_status = sgqlc.types.Field(WebhookStatus, graphql_name="webhookStatus")
    """Webhook status info for this job (only for dbt Cloud jobs)"""


class DbtJobExecution(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "job",
        "started_at",
        "finished_at",
        "status",
        "dbt_cloud_run_id",
        "display_name",
        "invocation_id",
        "dbt_runs",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt job execution"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    job = sgqlc.types.Field(sgqlc.types.non_null(DbtJob), graphql_name="job")
    """dbt job that was executed"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """dbt job execution start time"""

    finished_at = sgqlc.types.Field(DateTime, graphql_name="finishedAt")
    """dbt job execution finish time"""

    status = sgqlc.types.Field(DbtJobExecutionStatuses, graphql_name="status")
    """Status of dbt job execution"""

    dbt_cloud_run_id = sgqlc.types.Field(String, graphql_name="dbtCloudRunId")
    """dbt cloud job run id. Null for dbt core"""

    display_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="displayName")
    """dbt job execution display name"""

    invocation_id = sgqlc.types.Field(String, graphql_name="invocationId")
    """dbt run invocation id. Null for dbt cloud"""

    dbt_runs = sgqlc.types.Field(
        sgqlc.types.non_null(DbtRunConnection),
        graphql_name="dbtRuns",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """dbt job execution that this run is a part of

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DbtNode(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "unique_id",
        "database",
        "schema",
        "name",
        "alias",
        "description",
        "path",
        "resource_type",
        "raw_sql",
        "compiled_code",
        "compiled_path",
        "raw_node_json",
        "dbt_project",
        "table",
        "snooze_until_time",
        "dbt_run_steps",
        "test_dbt_run_steps",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt project"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    unique_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="uniqueId")
    """dbt unique ID for node"""

    database = sgqlc.types.Field(String, graphql_name="database")
    """dbt model database"""

    schema = sgqlc.types.Field(String, graphql_name="schema")
    """dbt model schema"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """dbt model name"""

    alias = sgqlc.types.Field(String, graphql_name="alias")
    """dbt model alias"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """dbt model description"""

    path = sgqlc.types.Field(String, graphql_name="path")
    """dbt model path"""

    resource_type = sgqlc.types.Field(String, graphql_name="resourceType")
    """dbt model resource type"""

    raw_sql = sgqlc.types.Field(String, graphql_name="rawSql")
    """dbt model definition"""

    compiled_code = sgqlc.types.Field(String, graphql_name="compiledCode")
    """dbt model compiled code"""

    compiled_path = sgqlc.types.Field(String, graphql_name="compiledPath")
    """dbt model compiled path"""

    raw_node_json = sgqlc.types.Field(String, graphql_name="rawNodeJson")
    """dbt model raw manifest json"""

    dbt_project = sgqlc.types.Field(sgqlc.types.non_null("DbtProject"), graphql_name="dbtProject")
    """Associated dbt project"""

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")
    """Associated table"""

    snooze_until_time = sgqlc.types.Field(DateTime, graphql_name="snoozeUntilTime")

    dbt_run_steps = sgqlc.types.Field(
        DbtRunStepConnection,
        graphql_name="dbtRunSteps",
        args=sgqlc.types.ArgDict(
            (
                (
                    "run_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="runStartTime", default=None),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="runEndTime", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Run steps associated with node

    Arguments:

    * `run_start_time` (`DateTime`): Filter by start time of dbt run
    * `run_end_time` (`DateTime`): Filter by end time of dbt run
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    test_dbt_run_steps = sgqlc.types.Field(
        DbtRunStepConnection,
        graphql_name="testDbtRunSteps",
        args=sgqlc.types.ArgDict(
            (
                (
                    "run_start_time",
                    sgqlc.types.Arg(DateTime, graphql_name="runStartTime", default=None),
                ),
                (
                    "run_end_time",
                    sgqlc.types.Arg(DateTime, graphql_name="runEndTime", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Test run steps associated with node

    Arguments:

    * `run_start_time` (`DateTime`): Filter by start time of dbt run
    * `run_end_time` (`DateTime`): Filter by end time of dbt run
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class DbtProject(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "connection",
        "project_id",
        "project_name",
        "source",
        "remote_url",
        "subdirectory",
        "config",
        "last_model_import",
        "last_test_import",
        "name",
        "last_webhook_received",
        "dbt_jobs",
        "dbt_nodes",
        "dbt_edges",
        "dbt_runs",
        "generate_incidents_for_model_failures",
        "generate_incidents_for_test_failures",
        "generate_incidents_for_test_warnings",
        "generate_incidents_for_snapshot_failures",
        "generate_incidents_for_seed_failures",
        "generate_alerts_for_model_failures",
        "generate_alerts_for_test_failures",
        "generate_alerts_for_test_warnings",
        "generate_alerts_for_snapshot_failures",
        "generate_alerts_for_seed_failures",
        "webhook_status",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt project"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    connection = sgqlc.types.Field(Connection, graphql_name="connection")
    """dbt connection"""

    project_id = sgqlc.types.Field(String, graphql_name="projectId")
    """External project identifier (e.g. dbt Cloud)"""

    project_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="projectName")
    """dbt project name"""

    source = sgqlc.types.Field(sgqlc.types.non_null(DbtProjectModelSource), graphql_name="source")
    """Source of data"""

    remote_url = sgqlc.types.Field(String, graphql_name="remoteUrl")
    """Remote location of the project sources"""

    subdirectory = sgqlc.types.Field(String, graphql_name="subdirectory")
    """Location of the project subdirectory"""

    config = sgqlc.types.Field(JSONString, graphql_name="config")
    """Project configuration"""

    last_model_import = sgqlc.types.Field(DateTime, graphql_name="lastModelImport")
    """The date of the last model import we know about"""

    last_test_import = sgqlc.types.Field(DateTime, graphql_name="lastTestImport")
    """The date of the last test import we know about"""

    name = sgqlc.types.Field(String, graphql_name="name")
    """A friendly name for the integration"""

    last_webhook_received = sgqlc.types.Field(DateTime, graphql_name="lastWebhookReceived")
    """The timestamp when the last webhook event was received (dbt Cloud
    only)
    """

    dbt_jobs = sgqlc.types.Field(
        DbtJobConnection,
        graphql_name="dbtJobs",
        args=sgqlc.types.ArgDict(
            (
                (
                    "match_on_catalog",
                    sgqlc.types.Arg(Boolean, graphql_name="matchOnCatalog", default=None),
                ),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `match_on_catalog` (`Boolean`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dbt_nodes = sgqlc.types.Field(
        sgqlc.types.non_null(DbtNodeConnection),
        graphql_name="dbtNodes",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated dbt project

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dbt_edges = sgqlc.types.Field(
        sgqlc.types.non_null(DbtEdgeConnection),
        graphql_name="dbtEdges",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated dbt project

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dbt_runs = sgqlc.types.Field(
        sgqlc.types.non_null(DbtRunConnection),
        graphql_name="dbtRuns",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated dbt project

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    generate_incidents_for_model_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateIncidentsForModelFailures"
    )

    generate_incidents_for_test_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateIncidentsForTestFailures"
    )

    generate_incidents_for_test_warnings = sgqlc.types.Field(
        Boolean, graphql_name="generateIncidentsForTestWarnings"
    )

    generate_incidents_for_snapshot_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateIncidentsForSnapshotFailures"
    )

    generate_incidents_for_seed_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateIncidentsForSeedFailures"
    )

    generate_alerts_for_model_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateAlertsForModelFailures"
    )

    generate_alerts_for_test_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateAlertsForTestFailures"
    )

    generate_alerts_for_test_warnings = sgqlc.types.Field(
        Boolean, graphql_name="generateAlertsForTestWarnings"
    )

    generate_alerts_for_snapshot_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateAlertsForSnapshotFailures"
    )

    generate_alerts_for_seed_failures = sgqlc.types.Field(
        Boolean, graphql_name="generateAlertsForSeedFailures"
    )

    webhook_status = sgqlc.types.Field(WebhookStatus, graphql_name="webhookStatus")
    """Webhook status info, or null for dbt Core (only dbt Cloud uses
    webhooks)
    """


class DbtRca(sgqlc.types.Type, IBaseRca):
    __schema__ = schema
    __field_names__ = (
        "rca_subtype",
        "job_error_type",
        "dbt_run_uuid",
        "mcon",
        "jobrun_root_error_type",
        "failed_nodes",
        "model_error_msg_base64",
        "rca_mn_ts",
        "start_time",
    )
    rca_subtype = sgqlc.types.Field(String, graphql_name="rcaSubtype")
    """Type of issue connected to node"""

    job_error_type = sgqlc.types.Field(String, graphql_name="jobErrorType")
    """resolve from jobrun_root_error_type"""

    dbt_run_uuid = sgqlc.types.Field(String, graphql_name="dbtRunUuid")
    """UUID of the dbt run"""

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """MCON of associated table"""

    jobrun_root_error_type = sgqlc.types.Field(String, graphql_name="jobrunRootErrorType")
    """The full root error type of the job"""

    failed_nodes = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="failedNodes")
    """List of failed nodes in the run"""

    model_error_msg_base64 = sgqlc.types.Field(String, graphql_name="modelErrorMsgBase64")
    """The error description for the failed node"""

    rca_mn_ts = sgqlc.types.Field(DateTime, graphql_name="rcaMnTs")
    """When the Airflow task started"""

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")
    """The RCA start time"""


class DbtRun(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "dbt_project",
        "job",
        "dbt_run_id",
        "run_logs",
        "generated_at",
        "started_at",
        "command",
        "branch",
        "job_execution",
        "dbt_run_steps",
        "has_logs",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt project"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    dbt_project = sgqlc.types.Field(sgqlc.types.non_null(DbtProject), graphql_name="dbtProject")
    """Associated dbt project"""

    job = sgqlc.types.Field(DbtJob, graphql_name="job")
    """Associated dbt job"""

    dbt_run_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="dbtRunId")
    """dbt run ID"""

    run_logs = sgqlc.types.Field(String, graphql_name="runLogs")
    """dbt run logs"""

    generated_at = sgqlc.types.Field(DateTime, graphql_name="generatedAt")
    """Time run_results.json was generated"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Time run started"""

    command = sgqlc.types.Field(String, graphql_name="command")
    """dbt command that was executed."""

    branch = sgqlc.types.Field(String, graphql_name="branch")
    """Code branch dbt command was executed against"""

    job_execution = sgqlc.types.Field(DbtJobExecution, graphql_name="jobExecution")
    """dbt job execution that this run is a part of"""

    dbt_run_steps = sgqlc.types.Field(
        sgqlc.types.non_null(DbtRunStepConnection),
        graphql_name="dbtRunSteps",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated dbt run

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    has_logs = sgqlc.types.Field(Boolean, graphql_name="hasLogs")
    """Indicates whether the dbt run has logs associated with it"""


class DbtRunStep(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "status",
        "started_at",
        "completed_at",
        "thread_id",
        "execution_time",
        "message",
        "raw_json",
        "compiled_code",
        "dbt_run",
        "node_unique_id",
        "table",
        "failed_records_count",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of dbt run step"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    status = sgqlc.types.Field(String, graphql_name="status")
    """Status, usually either success or failed"""

    started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt")
    """Execution start time"""

    completed_at = sgqlc.types.Field(DateTime, graphql_name="completedAt")
    """Execution end time"""

    thread_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="threadId")
    """Thread ID"""

    execution_time = sgqlc.types.Field(Float, graphql_name="executionTime")
    """Execution time elapsed"""

    message = sgqlc.types.Field(String, graphql_name="message")
    """Output message, e.g. SUCCESS"""

    raw_json = sgqlc.types.Field(String, graphql_name="rawJson")
    """dbt raw run result json"""

    compiled_code = sgqlc.types.Field(String, graphql_name="compiledCode")
    """The code that was executed"""

    dbt_run = sgqlc.types.Field(sgqlc.types.non_null(DbtRun), graphql_name="dbtRun")
    """Associated dbt run"""

    node_unique_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="nodeUniqueId")
    """dbt unique ID for node"""

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")
    """Associated table"""

    failed_records_count = sgqlc.types.Field(Int, graphql_name="failedRecordsCount")


class DomainRestriction(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "name",
        "description",
        "created_by",
        "tables",
        "obj_assignment_update_time",
        "data_products_created_in",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Domain UUID"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """Domain name"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """Domain description"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")

    tables = sgqlc.types.Field(
        sgqlc.types.non_null(WarehouseTableConnection),
        graphql_name="tables",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `full_table_id` (`String`)None
    """

    obj_assignment_update_time = sgqlc.types.Field(DateTime, graphql_name="objAssignmentUpdateTime")
    """Last update time for object assignments cause by domain changes
    (as opposed to catalog changes)
    """

    data_products_created_in = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductsCreatedIn",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Related data product created in a domain

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class Event(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "event_type",
        "account_uuid",
        "created_time",
        "anomaly",
        "data",
        "ack_by",
        "ack_timestamp",
        "event_state",
        "notified_users",
        "total_comments",
        "importance_score",
        "is_important",
        "is_child",
        "uuid",
        "warehouse",
        "table",
        "monitor_id",
        "parent_monitor_id",
        "custom_rule_entities",
        "custom_rule_projects",
        "custom_rule_datasets",
        "incident",
        "original_incident",
        "event_generated_time",
        "etl_container",
        "event_tables",
        "detector_feedback",
        "rca_jobs",
        "rca_status",
        "has_live_freshness",
        "has_reproduction_queries",
        "has_sampling",
        "alert",
        "table_stats",
        "mc_sql",
        "source_sql",
        "custom_sql",
        "evaluations",
        "is_merged",
        "description",
        "mentioned_users",
        "agent_span_filters",
        "filters",
    )
    event_type = sgqlc.types.Field(
        sgqlc.types.non_null(EventModelEventType), graphql_name="eventType"
    )

    account_uuid = sgqlc.types.Field(UUID, graphql_name="accountUuid")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    anomaly = sgqlc.types.Field("TableAnomaly", graphql_name="anomaly")

    data = sgqlc.types.Field(JSONString, graphql_name="data")

    ack_by = sgqlc.types.Field("User", graphql_name="ackBy")

    ack_timestamp = sgqlc.types.Field(DateTime, graphql_name="ackTimestamp")

    event_state = sgqlc.types.Field(
        sgqlc.types.non_null(EventModelEventState), graphql_name="eventState"
    )

    notified_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="notifiedUsers"
    )

    total_comments = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalComments")

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")

    is_child = sgqlc.types.Field(Boolean, graphql_name="isChild")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")

    monitor_id = sgqlc.types.Field(UUID, graphql_name="monitorId")

    parent_monitor_id = sgqlc.types.Field(UUID, graphql_name="parentMonitorId")

    custom_rule_entities = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="customRuleEntities"
    )
    """Tables referenced if has a custom rule"""

    custom_rule_projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="customRuleProjects"
    )
    """Projects referenced if has a custom rule"""

    custom_rule_datasets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="customRuleDatasets"
    )
    """Datasets referenced if has a custom rule"""

    incident = sgqlc.types.Field("Incident", graphql_name="incident")

    original_incident = sgqlc.types.Field("Incident", graphql_name="originalIncident")
    """Indicates if this event originally belonged to another incident
    (set by the system) and has been moved to the current incident by
    a user.
    """

    event_generated_time = sgqlc.types.Field(DateTime, graphql_name="eventGeneratedTime")

    etl_container = sgqlc.types.Field(EtlContainer, graphql_name="etlContainer")

    event_tables = sgqlc.types.Field(
        sgqlc.types.non_null(WarehouseTableConnection),
        graphql_name="eventTables",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
            )
        ),
    )
    """See note in EventAssetModel.table before using

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `full_table_id` (`String`)None
    """

    detector_feedback = sgqlc.types.Field("EventDetectorFeedback", graphql_name="detectorFeedback")
    """Feedback for the detector about the event"""

    rca_jobs = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(RcaJob))),
        graphql_name="rcaJobs",
    )

    rca_status = sgqlc.types.Field(sgqlc.types.list_of(EventRcaStatus), graphql_name="rcaStatus")
    """RCA status associated with the event"""

    has_live_freshness = sgqlc.types.Field(Boolean, graphql_name="hasLiveFreshness")

    has_reproduction_queries = sgqlc.types.Field(Boolean, graphql_name="hasReproductionQueries")

    has_sampling = sgqlc.types.Field(Boolean, graphql_name="hasSampling")

    alert = sgqlc.types.Field(Alert, graphql_name="alert")

    table_stats = sgqlc.types.Field("TableStats", graphql_name="tableStats")
    """Stats for the table connected to the event"""

    mc_sql = sgqlc.types.Field(String, graphql_name="mcSql")
    """easily to understand MC sql"""

    source_sql = sgqlc.types.Field(String, graphql_name="sourceSql")
    """Data source SQL for monitors using a custom SQL source."""

    custom_sql = sgqlc.types.Field(String, graphql_name="customSql")
    """Custom SQL for custom SQL monitors"""

    evaluations = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(EventEvaluation)), graphql_name="evaluations"
    )
    """Evaluation details for the fields associated with the event, for
    agent monitors
    """

    is_merged = sgqlc.types.Field(Boolean, graphql_name="isMerged")
    """Whether the event originally belonged to another alert which was
    merged into the alert currently associated to this event.
    """

    description = sgqlc.types.Field(String, graphql_name="description")
    """Human-readable description of the event"""

    mentioned_users = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("User")), graphql_name="mentionedUsers"
    )
    """Users that are mentioned in any of the comments"""

    agent_span_filters = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilter)), graphql_name="agentSpanFilters"
    )
    """agent span filters used on the monitor"""

    filters = sgqlc.types.Field("FilterGroup", graphql_name="filters")
    """filters used on the monitor"""


class EventDataIncidentCommentTimeline(sgqlc.types.Type, IEventDataBaseTimeline):
    __schema__ = schema
    __field_names__ = ("comment",)
    comment = sgqlc.types.Field(String, graphql_name="comment")
    """Incident comment"""


class EventDataIncidentOwnerUpdateTimeline(sgqlc.types.Type, IEventDataBaseTimeline):
    __schema__ = schema
    __field_names__ = ("owner", "old_owner")
    owner = sgqlc.types.Field(String, graphql_name="owner")
    """Current incident owner"""

    old_owner = sgqlc.types.Field(String, graphql_name="oldOwner")
    """Previous incident owner"""


class EventDataIncidentReactionUpdateTimeline(sgqlc.types.Type, IEventDataBaseTimeline):
    __schema__ = schema
    __field_names__ = ("type", "old_type", "reasons", "comment")
    type = sgqlc.types.Field(String, graphql_name="type")
    """Current reaction type"""

    old_type = sgqlc.types.Field(String, graphql_name="oldType")
    """Previous reaction type"""

    reasons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="reasons")
    """Reaction reasons"""

    comment = sgqlc.types.Field(String, graphql_name="comment")
    """Reaction comment"""


class EventDataIncidentSeverityUpdateTimeline(sgqlc.types.Type, IEventDataBaseTimeline):
    __schema__ = schema
    __field_names__ = ("severity", "old_severity")
    severity = sgqlc.types.Field(String, graphql_name="severity")
    """Current incident severity"""

    old_severity = sgqlc.types.Field(String, graphql_name="oldSeverity")
    """Previous incident severity"""


class EventDataIncidentSplitTimeline(sgqlc.types.Type, IEventDataBaseTimeline):
    __schema__ = schema
    __field_names__ = ("event_num",)
    event_num = sgqlc.types.Field(Int, graphql_name="eventNum")
    """Number of events split from incident"""


class EventDataIncidentStatusUpdateTimeline(sgqlc.types.Type, IEventDataBaseTimeline):
    __schema__ = schema
    __field_names__ = ("status", "old_status")
    status = sgqlc.types.Field(String, graphql_name="status")
    """Current incident status"""

    old_status = sgqlc.types.Field(String, graphql_name="oldStatus")
    """Previous incident status"""


class EventDetectorFeedback(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "is_false_positive",
        "reason",
        "metric",
        "field",
        "where_condition",
        "time_series_uuid",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    is_false_positive = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isFalsePositive"
    )
    """Deprecated - use 'reason' field instead. Whether the event is
    considered a false positive.
    """

    reason = sgqlc.types.Field(sgqlc.types.non_null(FeedbackReason), graphql_name="reason")
    """Reason for the feedback."""

    metric = sgqlc.types.Field(String, graphql_name="metric")

    field = sgqlc.types.Field(String, graphql_name="field")

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")

    time_series_uuid = sgqlc.types.Field(UUID, graphql_name="timeSeriesUuid")


class FailedDataRca(sgqlc.types.Type, IBaseRca, IQueryRca):
    __schema__ = schema
    __field_names__ = ("error_code", "error_msg")
    error_code = sgqlc.types.Field(String, graphql_name="errorCode")
    """The internal error code type"""

    error_msg = sgqlc.types.Field(String, graphql_name="errorMsg")
    """The error msg from the warehouse"""


class FilterBinary(sgqlc.types.Type, FilterInterface):
    __schema__ = schema
    __field_names__ = ("predicate", "left", "right")
    predicate = sgqlc.types.Field(sgqlc.types.non_null(FilterPredicate), graphql_name="predicate")

    left = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface))),
        graphql_name="left",
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface))),
        graphql_name="right",
    )


class FilterGroup(sgqlc.types.Type, FilterInterface):
    __schema__ = schema
    __field_names__ = ("conditions", "operator")
    conditions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FilterInterface))),
        graphql_name="conditions",
    )

    operator = sgqlc.types.Field(sgqlc.types.non_null(BooleanOperator), graphql_name="operator")


class FilterSql(sgqlc.types.Type, FilterInterface):
    __schema__ = schema
    __field_names__ = ("sql",)
    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")


class FilterUnary(sgqlc.types.Type, FilterInterface):
    __schema__ = schema
    __field_names__ = ("predicate", "value")
    predicate = sgqlc.types.Field(sgqlc.types.non_null(FilterPredicate), graphql_name="predicate")

    value = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FilterValueInterface))),
        graphql_name="value",
    )


class FilterValueField(sgqlc.types.Type, FilterValueInterface):
    __schema__ = schema
    __field_names__ = ("field", "table", "mcon")
    field = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="field")

    table = sgqlc.types.Field(String, graphql_name="table")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")


class FilterValueLiteral(sgqlc.types.Type, FilterValueInterface):
    __schema__ = schema
    __field_names__ = ("literal",)
    literal = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="literal")


class FilterValueSql(sgqlc.types.Type, FilterValueInterface):
    __schema__ = schema
    __field_names__ = ("sql",)
    sql = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="sql")


class FivetranConnector(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "deleted_at",
        "uuid",
        "mcon",
        "account_id",
        "resource_id",
        "fivetran_destination",
        "fivetran_id",
        "service",
        "schema",
        "source_sync_details",
        "created_at",
        "succeeded_at",
        "failed_at",
        "sync_frequency",
        "setup_state",
        "sync_state",
        "update_state",
        "tables",
        "tasks",
        "warnings",
        "fivetran_status",
        "fivetran_url",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Internal surrogate ID of Fivetran Connector"""

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")
    """Fivetran etl container id"""

    fivetran_destination = sgqlc.types.Field(
        sgqlc.types.non_null("FivetranDestination"), graphql_name="fivetranDestination"
    )

    fivetran_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fivetranId")

    service = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="service")

    schema = sgqlc.types.Field(String, graphql_name="schema")
    """The schema of a Fivetran Connector"""

    source_sync_details = sgqlc.types.Field(JSONString, graphql_name="sourceSyncDetails")
    """Information about the synced source accounts"""

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """Timestamp of when a connector is created"""

    succeeded_at = sgqlc.types.Field(DateTime, graphql_name="succeededAt")
    """Timestamp of a connector's last successful sync"""

    failed_at = sgqlc.types.Field(DateTime, graphql_name="failedAt")
    """Timestamp of a connector's last failed sync"""

    sync_frequency = sgqlc.types.Field(Int, graphql_name="syncFrequency")
    """The sync frequency of a connector in minutes"""

    setup_state = sgqlc.types.Field(FivetranConnectorSetupStates, graphql_name="setupState")

    sync_state = sgqlc.types.Field(FivetranConnectorSyncStates, graphql_name="syncState")

    update_state = sgqlc.types.Field(FivetranConnectorUpdateStates, graphql_name="updateState")

    tables = sgqlc.types.Field(
        WarehouseTableConnection,
        graphql_name="tables",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                (
                    "full_table_id",
                    sgqlc.types.Arg(String, graphql_name="fullTableId", default=None),
                ),
            )
        ),
    )
    """The warehouse tables that the connector is associated with. Note
    that the list of tables here is subjected to the `tableMcons`
    filter variable provided by users.

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `full_table_id` (`String`)None
    """

    tasks = sgqlc.types.Field(JSONString, graphql_name="tasks")
    """Tasks needed to fix the connector status"""

    warnings = sgqlc.types.Field(JSONString, graphql_name="warnings")
    """Warnings related to the connector status"""

    fivetran_status = sgqlc.types.Field(FivetranConnectorStatuses, graphql_name="fivetranStatus")

    fivetran_url = sgqlc.types.Field(String, graphql_name="fivetranUrl")
    """The URL to the connector page in Fivetran"""


class FivetranDestination(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "uuid",
        "account_id",
        "fivetran_id",
        "group_id",
        "service",
        "config",
        "warehouse",
        "fivetran_connectors",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Internal surrogate ID of Fivetran Destination"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    fivetran_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fivetranId")
    """Fivetran internal ID"""

    group_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="groupId")
    """Associated Fivetran Group ID"""

    service = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="service")
    """Kind of destination"""

    config = sgqlc.types.Field(JSONString, graphql_name="config")
    """Service-specific config payload"""

    warehouse = sgqlc.types.Field(Warehouse, graphql_name="warehouse")

    fivetran_connectors = sgqlc.types.Field(
        sgqlc.types.non_null(FivetranConnectorConnection),
        graphql_name="fivetranConnectors",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class FutileDataRca(sgqlc.types.Type, IBaseRca, IQueryRca):
    __schema__ = schema
    __field_names__ = ()


class GithubPullRequest(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "url",
        "title",
        "issue_number",
        "author",
        "repository_name",
        "repository_owner",
        "repository_url",
        "merged_at",
        "number_of_files_changed",
        "files_changed",
        "score",
        "impact",
        "provider",
    )
    url = sgqlc.types.Field(String, graphql_name="url")
    """PR URL"""

    title = sgqlc.types.Field(String, graphql_name="title")
    """PR title"""

    issue_number = sgqlc.types.Field(Int, graphql_name="issueNumber")
    """PR issue number"""

    author = sgqlc.types.Field(GithubUser, graphql_name="author")
    """PR author"""

    repository_name = sgqlc.types.Field(String, graphql_name="repositoryName")
    """Repository name"""

    repository_owner = sgqlc.types.Field(String, graphql_name="repositoryOwner")
    """Repository owner"""

    repository_url = sgqlc.types.Field(String, graphql_name="repositoryUrl")
    """Repository URL"""

    merged_at = sgqlc.types.Field(DateTime, graphql_name="mergedAt")
    """Time the PR was merged at"""

    number_of_files_changed = sgqlc.types.Field(Int, graphql_name="numberOfFilesChanged")
    """Number of files changed in the PR"""

    files_changed = sgqlc.types.Field(
        sgqlc.types.list_of(GithubPullRequestFile), graphql_name="filesChanged"
    )
    """List of files changed in the PR"""

    score = sgqlc.types.Field(Float, graphql_name="score")
    """Score of the PR being relevant to the incident. 100% means that
    the PR is 100% relevant to the incident.
    """

    impact = sgqlc.types.Field(sgqlc.types.list_of(GithubPullRequestImpact), graphql_name="impact")
    """Impact of the (merged) pull request on resources"""

    provider = sgqlc.types.Field(Provider, graphql_name="provider")
    """VCS integration provider"""


class Incident(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "warehouse",
        "created_time",
        "updated_time",
        "owner",
        "severity",
        "priority",
        "system_set_severity",
        "feedback",
        "feedback_time",
        "last_update_user",
        "project",
        "dataset",
        "schema",
        "incident_type",
        "incident_sub_types",
        "incident_time",
        "lock_incident",
        "can_roll_up",
        "etl_container",
        "name",
        "merged_into_incident",
        "account",
        "asset_mcons",
        "merged_alerts",
        "events",
        "original_events",
        "slack_msg_details",
        "original_slack_msg_details",
        "jira_tickets",
        "servicenow_incidents",
        "gh_insights",
        "summary",
        "owner_full_name",
        "topology",
        "table_mcons",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """Effective ID of an incident"""

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")
    """Warehouse an incident belongs to"""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """Time an incident was created on (i.e. first event)"""

    updated_time = sgqlc.types.Field(DateTime, graphql_name="updatedTime")
    """Time an incident was last updated"""

    owner = sgqlc.types.Field(String, graphql_name="owner")
    """Owner assigned to the incident"""

    severity = sgqlc.types.Field(String, graphql_name="severity")
    """Incident severity"""

    priority = sgqlc.types.Field(IncidentModelPriority, graphql_name="priority")
    """Incident priority"""

    system_set_severity = sgqlc.types.Field(String, graphql_name="systemSetSeverity")
    """Severity set by the system on incident creation"""

    feedback = sgqlc.types.Field(IncidentModelFeedback, graphql_name="feedback")
    """Any user feedback for an incident"""

    feedback_time = sgqlc.types.Field(DateTime, graphql_name="feedbackTime")
    """Time when user provided feedback"""

    last_update_user = sgqlc.types.Field(JSONString, graphql_name="lastUpdateUser")
    """Who last updated the incident"""

    project = sgqlc.types.Field(String, graphql_name="project")
    """Project (or database/catalog) tables in an incident belong to. If
    any
    """

    dataset = sgqlc.types.Field(String, graphql_name="dataset")
    """Dataset (or schema) tables in an incident belong to. If any"""

    schema = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="schema"
    )
    """project:dataset pairs"""

    incident_type = sgqlc.types.Field(IncidentModelIncidentType, graphql_name="incidentType")
    """Type of incident"""

    incident_sub_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="incidentSubTypes"
    )
    """All the incident sub-types that this incident matches, based on
    the type of the events that this incident includes.
    """

    incident_time = sgqlc.types.Field(DateTime, graphql_name="incidentTime")
    """Time which serves as the base of the grouping window"""

    lock_incident = sgqlc.types.Field(Boolean, graphql_name="lockIncident")
    """True if events should not be added to this incident"""

    can_roll_up = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="canRollUp")
    """Used for noise reduction of notifications for custom rules. If
    True, events can still be rolled up into this incident
    """

    etl_container = sgqlc.types.Field(EtlContainer, graphql_name="etlContainer")

    name = sgqlc.types.Field(String, graphql_name="name")
    """Custom name provided by user"""

    merged_into_incident = sgqlc.types.Field("Incident", graphql_name="mergedIntoIncident")
    """Indicates that this incident has been merged into another and
    should be considered 'deleted'
    """

    account = sgqlc.types.Field(Account, graphql_name="account")

    asset_mcons = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="assetMcons"
    )
    """MCONs of tables/jobs associated with the incident"""

    merged_alerts = sgqlc.types.Field(
        sgqlc.types.non_null(IncidentConnection),
        graphql_name="mergedAlerts",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Indicates that this incident has been merged into another and
    should be considered 'deleted'

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    events = sgqlc.types.Field(
        EventConnection,
        graphql_name="events",
        args=sgqlc.types.ArgDict(
            (
                ("event_type", sgqlc.types.Arg(String, graphql_name="eventType", default=None)),
                ("event_state", sgqlc.types.Arg(String, graphql_name="eventState", default=None)),
                (
                    "include_timeline_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeTimelineEvents", default=None),
                ),
                (
                    "include_anomaly_events",
                    sgqlc.types.Arg(Boolean, graphql_name="includeAnomalyEvents", default=None),
                ),
                ("desc_order", sgqlc.types.Arg(Boolean, graphql_name="descOrder", default=None)),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `event_type` (`String`)None
    * `event_state` (`String`)None
    * `include_timeline_events` (`Boolean`): Flag indicates whether
      include timeline events or not. If event_type specified, this
      flag will be ignored
    * `include_anomaly_events` (`Boolean`): Flag indicates whether
      include anomaly events or not. If event_type specified, this
      flag will be ignored
    * `desc_order` (`Boolean`): Returns events in descending order of
      create_time
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    original_events = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="originalEvents",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Indicates if this event originally belonged to another incident
    (set by the system) and has been moved to the current incident by
    a user.

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    slack_msg_details = sgqlc.types.Field(
        sgqlc.types.non_null(SlackMessageDetailsConnection),
        graphql_name="slackMsgDetails",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    original_slack_msg_details = sgqlc.types.Field(
        sgqlc.types.non_null(SlackMessageDetailsConnection),
        graphql_name="originalSlackMsgDetails",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Indicates that this slack msg originally belonged to another
    incident (set by the system) and has been re-assigned to the
    current incident when incidents were merged together.

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    jira_tickets = sgqlc.types.Field(
        sgqlc.types.list_of(JiraTicketOutput), graphql_name="jiraTickets"
    )
    """Jira tickets associated with the incident"""

    servicenow_incidents = sgqlc.types.Field(
        sgqlc.types.list_of(ServiceNowIncidentOutput), graphql_name="servicenowIncidents"
    )
    """ServiceNow incidents associated with the incident"""

    gh_insights = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(GithubPullRequestInsight))),
        graphql_name="ghInsights",
    )
    """Reference to the related incident"""

    summary = sgqlc.types.Field(IncidentSummary, graphql_name="summary")
    """Get summary info for incident"""

    owner_full_name = sgqlc.types.Field(String, graphql_name="ownerFullName")
    """Full name of the user who is the owner of the incident or email if
    user does not exist
    """

    topology = sgqlc.types.Field(IncidentTopology, graphql_name="topology")
    """Extra information about relation between events in the incident"""

    table_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="tableMcons")
    """MCONs of tables directly impacted by the incident"""


class JiraTicket(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = ("ticket_url", "ticket_key", "created_at", "created_by", "integration_id")
    ticket_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ticketUrl")
    """Ticket URL in Jira"""

    ticket_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ticketKey")
    """Ticket external ID"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")

    created_by = sgqlc.types.Field(sgqlc.types.non_null(UserOutput), graphql_name="createdBy")

    integration_id = sgqlc.types.Field(UUID, graphql_name="integrationId")
    """Jira integration ID"""


class JobPerformanceSummary(sgqlc.types.Type, IEtlAssetPerformanceSummary):
    """ETL Job performance summary"""

    __schema__ = schema
    __field_names__ = ()


class JobRca(sgqlc.types.Type, IBaseRca):
    __schema__ = schema
    __field_names__ = ("mcon",)
    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """The MCON of the table associated with the RCA"""


class MergedAlert(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = ("merged_into_alert_id",)
    merged_into_alert_id = sgqlc.types.Field(UUID, graphql_name="mergedIntoAlertId")
    """UUID of the alert that this alert was merged into"""


class MetricMonitoring(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "account_uuid",
        "projects",
        "datasets",
        "is_deleted",
        "deleted_at",
        "description",
        "notes",
        "labels",
        "failure_audiences",
        "is_template_managed",
        "namespace",
        "severity",
        "priority",
        "comparisons",
        "is_paused",
        "is_draft",
        "type",
        "warehouse_uuid",
        "data_source",
        "source_data_source",
        "fields",
        "entities_arr",
        "created_time",
        "created_by",
        "time_axis_field_name",
        "time_axis_field_type",
        "unnest_fields",
        "agg_time_interval",
        "where_condition",
        "use_partition_clause",
        "schedule",
        "monitor_name",
        "disable_look_back_bootstrap",
        "high_segment_count",
        "segment_count_hint",
        "segmented_expressions",
        "segmentation_type",
        "min_segment_size",
        "last_update_user",
        "last_update_time",
        "collection_lag_hours",
        "version",
        "sql_blocks",
        "sampling_config",
        "table",
        "entities",
        "selected_metrics",
        "history_days",
        "training_config",
        "sensitivity",
        "select_expressions",
        "mcon",
        "full_table_id",
        "monitor_type",
        "schedule_config",
        "notification_settings",
        "agg_select_expression",
        "bootstrap",
        "notify_rule_run_failure",
        "agent_span_filters",
        "filters",
        "connection_id",
        "timeout",
        "domain_uuids",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    account_uuid = sgqlc.types.Field(UUID, graphql_name="accountUuid")
    """Customer account id"""

    projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="projects"
    )
    """Databases associated with the monitor"""

    datasets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="datasets"
    )
    """Schemas associated with the monitor"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    description = sgqlc.types.Field(String, graphql_name="description")

    notes = sgqlc.types.Field(String, graphql_name="notes")

    labels = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorLabelObject))),
        graphql_name="labels",
    )

    failure_audiences = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorLabelObject))),
        graphql_name="failureAudiences",
    )

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )
    """Is this monitor managed by a configuration template (monitors-as-
    code)?
    """

    namespace = sgqlc.types.Field(String, graphql_name="namespace")
    """Namespace of rule, used for monitors-as-code"""

    severity = sgqlc.types.Field(String, graphql_name="severity")
    """Default severity for incidents involving this monitor"""

    priority = sgqlc.types.Field(MetricMonitoringModelPriority, graphql_name="priority")
    """Default priority for alerts involving this monitor"""

    comparisons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparison)), graphql_name="comparisons"
    )

    is_paused = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPaused")
    """Is this monitor paused?"""

    is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft")
    """Is this a draft monitor?"""

    type = sgqlc.types.Field(sgqlc.types.non_null(MetricMonitoringModelType), graphql_name="type")

    warehouse_uuid = sgqlc.types.Field(UUID, graphql_name="warehouseUuid")
    """Warehouse to query"""

    data_source = sgqlc.types.Field(MonitorDataSource, graphql_name="dataSource")

    source_data_source = sgqlc.types.Field(MonitorDataSource, graphql_name="sourceDataSource")

    fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fields"
    )

    entities_arr = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entitiesArr"
    )
    """Tables referenced in query"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the monitor was first created"""

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Who added the monitor"""

    time_axis_field_name = sgqlc.types.Field(String, graphql_name="timeAxisFieldName")

    time_axis_field_type = sgqlc.types.Field(String, graphql_name="timeAxisFieldType")

    unnest_fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="unnestFields"
    )

    agg_time_interval = sgqlc.types.Field(String, graphql_name="aggTimeInterval")

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")

    use_partition_clause = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usePartitionClause"
    )
    """Flag to use automatic partition filter in query"""

    schedule = sgqlc.types.Field(
        sgqlc.types.non_null(DataCollectorSchedule), graphql_name="schedule"
    )

    monitor_name = sgqlc.types.Field(String, graphql_name="monitorName")
    """Name of monitor, must be unique per account, used for rule
    identityresolution for monitors-as-code
    """

    disable_look_back_bootstrap = sgqlc.types.Field(
        Boolean, graphql_name="disableLookBackBootstrap"
    )
    """Flag to disable the look back bootstrap for a monitor"""

    high_segment_count = sgqlc.types.Field(Boolean, graphql_name="highSegmentCount")
    """Flag to apply additional limits which increase the supported
    segment count
    """

    segment_count_hint = sgqlc.types.Field(Int, graphql_name="segmentCountHint")
    """Segment count when monitor was created, or cached result of the
    segment count for the latest job execution. Can be hinted when
    calling the API, to be served when editing the monitor if no
    execution already occurred and a fresh segment count is not
    available.
    """

    segmented_expressions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="segmentedExpressions"
    )
    """Fields or expressions to segment by"""

    segmentation_type = sgqlc.types.Field(String, graphql_name="segmentationType")
    """The type of segmentation specified in segmented_expressions. For
    instance field or custom_sql_expression.
    """

    min_segment_size = sgqlc.types.Field(Int, graphql_name="minSegmentSize")
    """Minimum number of rows for a segment to be retrieved. Segments
    with less rows than this will be discarded.
    """

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who was the last user to update the monitor"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the monitor was last updated"""

    collection_lag_hours = sgqlc.types.Field(Int, graphql_name="collectionLagHours")
    """Time to offset the collection time bucket by in hours. Field
    should be a multiple of 24 if agg_time_interval is set to DAY.
    Only used for version > 1 monitors.
    """

    version = sgqlc.types.Field(Int, graphql_name="version")
    """Configuration version of the monitor."""

    sql_blocks = sgqlc.types.Field(MonitorSqlBlocks, graphql_name="sqlBlocks")
    """SQL blocks used on the monitor"""

    sampling_config = sgqlc.types.Field(MonitorSamplingConfig, graphql_name="samplingConfig")
    """Sampling configuration"""

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")
    """Table related to monitor"""

    entities = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="entities")
    """Entities (e.g. tables) associated with monitor"""

    selected_metrics = sgqlc.types.Field(
        sgqlc.types.list_of(FieldHealthMetrics), graphql_name="selectedMetrics"
    )
    """Selected metrics for the monitor. If empty, all metrics will be
    monitored. Only available for Field Health monitors.
    """

    history_days = sgqlc.types.Field(Int, graphql_name="historyDays")

    training_config = sgqlc.types.Field(JSONString, graphql_name="trainingConfig")
    """Training configuration for the monitor"""

    sensitivity = sgqlc.types.Field(SensitivityLevels, graphql_name="sensitivity")
    """Sensitivity for automated thresholds"""

    select_expressions = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(MetricMonitorSelectExpression))
        ),
        graphql_name="selectExpressions",
    )

    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    full_table_id = sgqlc.types.Field(String, graphql_name="fullTableId")

    monitor_type = sgqlc.types.Field(String, graphql_name="monitorType")

    schedule_config = sgqlc.types.Field(ScheduleConfigOutput, graphql_name="scheduleConfig")

    notification_settings = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AccountNotificationSetting))),
        graphql_name="notificationSettings",
    )

    agg_select_expression = sgqlc.types.Field(String, graphql_name="aggSelectExpression")
    """(DEPRECATED) Option will be ignored"""

    bootstrap = sgqlc.types.Field(MonitorBootstrap, graphql_name="bootstrap")
    """Current bootstrap state of the monitor"""

    notify_rule_run_failure = sgqlc.types.Field(Boolean, graphql_name="notifyRuleRunFailure")
    """DEPRECATED: Replaced by failure audiences"""

    agent_span_filters = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilter)), graphql_name="agentSpanFilters"
    )
    """agent span filters used on the monitor"""

    filters = sgqlc.types.Field(FilterGroup, graphql_name="filters")
    """filters used on the monitor"""

    connection_id = sgqlc.types.Field(UUID, graphql_name="connectionId")
    """The connection UUID associated with the monitor"""

    timeout = sgqlc.types.Field(Int, graphql_name="timeout")
    """Timeout for the SQL query"""

    domain_uuids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainUuids"
    )
    """Domain UUIDs assigned to the monitor."""


class Monitor(
    sgqlc.types.Type,
    IMonitor,
    IMetricsMonitor,
    ICustomRulesMonitor,
    IMonitorStatus,
    IComparisonMonitor,
):
    __schema__ = schema
    __field_names__ = ()


class MonteCarloConfigTemplate(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "namespace",
        "template",
        "resolved_template",
        "created_time",
        "last_update_user",
        "last_update_time",
    )
    namespace = sgqlc.types.Field(String, graphql_name="namespace")
    """Namespace of rule, used for monitors-as-code"""

    template = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="template")
    """Input config template, as JSON"""

    resolved_template = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="resolvedTemplate"
    )
    """Config template with resolved object UUIDs, as JSON"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")


class ObjectProperty(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "mcon_id",
        "property_name",
        "property_value",
        "property_source_type",
        "property_source",
    )
    mcon_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mconId")
    """Unique asset identifier"""

    property_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="propertyName")
    """The name (key) of the property"""

    property_value = sgqlc.types.Field(String, graphql_name="propertyValue")
    """The value for the property"""

    property_source_type = sgqlc.types.Field(
        sgqlc.types.non_null(ObjectPropertyModelPropertySourceType),
        graphql_name="propertySourceType",
    )
    """The type of source property (i.e. how it was supplied)"""

    property_source = sgqlc.types.Field(String, graphql_name="propertySource")
    """The origin of the property (e.g. snowflake, bigquery, etc.)"""


class OpsgenieIncident(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = (
        "created_by",
        "alias",
        "alert_id",
        "tiny_id",
        "originates_from_mc_notification",
        "incident_url",
        "integration_id",
        "created_at",
    )
    created_by = sgqlc.types.Field(sgqlc.types.non_null(UserOutput), graphql_name="createdBy")

    alias = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="alias")

    alert_id = sgqlc.types.Field(String, graphql_name="alertId")

    tiny_id = sgqlc.types.Field(String, graphql_name="tinyId")

    originates_from_mc_notification = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="originatesFromMcNotification"
    )

    incident_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="incidentUrl")
    """Opsgenie incident URL"""

    integration_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="integrationId")
    """Opsgenie integration ID"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")


class Project(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "deleted_at",
        "uuid",
        "warehouse",
        "project",
        "mcon",
        "created_at",
        "updated_at",
        "is_excluded",
        "table_count",
    )
    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")

    project = sgqlc.types.Field(String, graphql_name="project")

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt")
    """Timestamp of when a database (project) is created."""

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")
    """Timestamp of when a database (project) is updated."""

    is_excluded = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExcluded")

    table_count = sgqlc.types.Field(Int, graphql_name="tableCount")
    """Number of tables in the project"""


class QdrDataRca(sgqlc.types.Type, IBaseRca, IQueryRca):
    __schema__ = schema
    __field_names__ = ()


class RecommendationConfigMetricMonitor(sgqlc.types.Type, RecommendationConfigInterface):
    __schema__ = schema
    __field_names__ = (
        "time_axis_name",
        "time_axis_type",
        "where_condition",
        "agg_time_interval",
        "lookback_days",
        "comparisons",
        "collection_lag_hours",
        "segmented_expressions",
        "segmentation_type",
    )
    time_axis_name = sgqlc.types.Field(String, graphql_name="timeAxisName")

    time_axis_type = sgqlc.types.Field(String, graphql_name="timeAxisType")

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")

    agg_time_interval = sgqlc.types.Field(String, graphql_name="aggTimeInterval")

    lookback_days = sgqlc.types.Field(Int, graphql_name="lookbackDays")

    comparisons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(CustomRuleComparison))),
        graphql_name="comparisons",
    )

    collection_lag_hours = sgqlc.types.Field(Int, graphql_name="collectionLagHours")

    segmented_expressions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="segmentedExpressions"
    )

    segmentation_type = sgqlc.types.Field(String, graphql_name="segmentationType")


class RecommendationConfigValidationMonitor(sgqlc.types.Type, RecommendationConfigInterface):
    __schema__ = schema
    __field_names__ = ("sql_blocks",)
    sql_blocks = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleSqlBlocks), graphql_name="sqlBlocks"
    )


class ReportArgumentsAlerts(sgqlc.types.Type, ReportArgumentsInterface):
    __schema__ = schema
    __field_names__ = ("monitor_id",)
    monitor_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="monitorId")


class ReportArgumentsConsumption(sgqlc.types.Type, ReportArgumentsInterface):
    __schema__ = schema
    __field_names__ = ()


class ReportArgumentsEvents(sgqlc.types.Type, ReportArgumentsInterface):
    __schema__ = schema
    __field_names__ = ("alert_id",)
    alert_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="alertId")


class Resource(sgqlc.types.Type, Node):
    """A resource which contains assets, e.g., a data warehouse, a report
    engine, etc
    """

    __schema__ = schema
    __field_names__ = (
        "uuid",
        "account",
        "name",
        "type",
        "is_user_provided",
        "is_default",
        "created_time",
        "last_update_user",
        "last_update_time",
        "collection_preferences",
        "asset_collection_preferences",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """The resource id"""

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")
    """Customer account"""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The name of the resource"""

    type = sgqlc.types.Field(String, graphql_name="type")
    """The type of the resource"""

    is_user_provided = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isUserProvided"
    )
    """If the resource was created / updated by Monte Carlo or a user"""

    is_default = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDefault")
    """If the resource is the account's default resource"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the resource was first created"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the resource"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the resource was last updated"""

    collection_preferences = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    asset_collection_preferences = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionPreferencesConnection),
        graphql_name="assetCollectionPreferences",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class ResponseMetadataMonitorRecommendations(sgqlc.types.Type, ResponseMetadataInterface):
    __schema__ = schema
    __field_names__ = ("monitor_recommendations",)
    monitor_recommendations = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(RecommendationConfigInterface))
        ),
        graphql_name="monitorRecommendations",
    )


class ResponseMetadataQuery(sgqlc.types.Type, ResponseMetadataInterface):
    __schema__ = schema
    __field_names__ = ("query_response_fields",)
    query_response_fields = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(QueryResponseField))),
        graphql_name="queryResponseFields",
    )


class ServiceNowCredentialsOAuthClientCredentials(sgqlc.types.Type, ServiceNowCredentialsInterface):
    __schema__ = schema
    __field_names__ = ("client_id", "client_secret")
    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")

    client_secret = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientSecret")


class ServiceNowCredentialsUsernamePassword(sgqlc.types.Type, ServiceNowCredentialsInterface):
    __schema__ = schema
    __field_names__ = ("username", "password")
    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")

    password = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="password")


class ServiceNowIncident(sgqlc.types.Type, NodeWithUUID):
    __schema__ = schema
    __field_names__ = (
        "incident_sys_id",
        "created_at",
        "originates_from_mc_notification",
        "incident_url",
    )
    incident_sys_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="incidentSysId")
    """Incident Sys Id in ServiceNow"""

    created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt")

    originates_from_mc_notification = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="originatesFromMcNotification"
    )

    incident_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="incidentUrl")
    """ServiceNow incident URL"""


class SlackChannelV2(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "account",
        "name",
        "channel_id",
        "topic",
        "purpose",
        "loading_start_time",
        "created_time",
        "team_id",
    )
    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")
    """The account associated with the slack channel."""

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")
    """The name of the slack channel"""

    channel_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="channelId")
    """The id for the slack channel"""

    topic = sgqlc.types.Field(String, graphql_name="topic")
    """The slack channel topic"""

    purpose = sgqlc.types.Field(String, graphql_name="purpose")
    """The slack channel purpose"""

    loading_start_time = sgqlc.types.Field(DateTime, graphql_name="loadingStartTime")
    """Timestamp when the channel was marked as loading"""

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """The time this record was created."""

    team_id = sgqlc.types.Field(String, graphql_name="teamId")


class SlackEngagement(sgqlc.types.Type, Node):
    """Slack Engagement Information"""

    __schema__ = schema
    __field_names__ = (
        "message",
        "uuid",
        "event_type",
        "event_ts",
        "data",
        "created_time",
        "updated_time",
        "is_merged",
    )
    message = sgqlc.types.Field(sgqlc.types.non_null("SlackMessageDetails"), graphql_name="message")

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    event_type = sgqlc.types.Field(SlackEngagementEventType, graphql_name="eventType")

    event_ts = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="eventTs")

    data = sgqlc.types.Field(JSONString, graphql_name="data")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    is_merged = sgqlc.types.Field(Boolean, graphql_name="isMerged")
    """Whether the engagement originally belonged to another alert which
    was merged into the alert currently associated to this engagement.
    """


class SlackMessageDetails(sgqlc.types.Type, Node):
    """Slack Message Information"""

    __schema__ = schema
    __field_names__ = (
        "incident",
        "original_incident",
        "notification_setting",
        "account",
        "permalink",
        "msg_ts",
        "engagements",
    )
    incident = sgqlc.types.Field(sgqlc.types.non_null(Incident), graphql_name="incident")

    original_incident = sgqlc.types.Field(Incident, graphql_name="originalIncident")
    """Indicates that this slack msg originally belonged to another
    incident (set by the system) and has been re-assigned to the
    current incident when incidents were merged together.
    """

    notification_setting = sgqlc.types.Field(
        AccountNotificationSetting, graphql_name="notificationSetting"
    )
    """Notification setting used to send this message"""

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    permalink = sgqlc.types.Field(String, graphql_name="permalink")

    msg_ts = sgqlc.types.Field(String, graphql_name="msgTs")

    engagements = sgqlc.types.Field(
        sgqlc.types.non_null(SlackEngagementConnection),
        graphql_name="engagements",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class TableAnomaly(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "unique_key",
        "grouping_key",
        "job_execution_uuid",
        "consolidating_uuid",
        "warehouse_uuid",
        "table",
        "rule_uuid",
        "anomaly_id",
        "detected_on",
        "start_time",
        "end_time",
        "is_active",
        "is_false_positive",
        "reason",
        "data",
        "events",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    unique_key = sgqlc.types.Field(String, graphql_name="uniqueKey")

    grouping_key = sgqlc.types.Field(String, graphql_name="groupingKey")

    job_execution_uuid = sgqlc.types.Field(UUID, graphql_name="jobExecutionUuid")

    consolidating_uuid = sgqlc.types.Field(UUID, graphql_name="consolidatingUuid")

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")

    table = sgqlc.types.Field("WarehouseTable", graphql_name="table")

    rule_uuid = sgqlc.types.Field(UUID, graphql_name="ruleUuid")

    anomaly_id = sgqlc.types.Field(String, graphql_name="anomalyId")

    detected_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="detectedOn")

    start_time = sgqlc.types.Field(DateTime, graphql_name="startTime")

    end_time = sgqlc.types.Field(DateTime, graphql_name="endTime")

    is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive")

    is_false_positive = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isFalsePositive"
    )

    reason = sgqlc.types.Field(sgqlc.types.non_null(TableAnomalyModelReason), graphql_name="reason")

    data = sgqlc.types.Field(JSONString, graphql_name="data")

    events = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="events",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class TableField(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "version",
        "name",
        "field_type",
        "mode",
        "description",
        "original_name",
        "data_metric_time_field",
        "is_time_field",
        "is_text_field",
        "is_numeric_field",
        "is_boolean_field",
        "most_recent_use_in_same_table",
        "most_recent_use_in_another_table",
        "field_mcon",
        "object_properties",
        "object_metadata",
    )
    version = sgqlc.types.Field(sgqlc.types.non_null("TableSchemaVersion"), graphql_name="version")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    field_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fieldType")

    mode = sgqlc.types.Field(String, graphql_name="mode")

    description = sgqlc.types.Field(String, graphql_name="description")

    original_name = sgqlc.types.Field(String, graphql_name="originalName")

    data_metric_time_field = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="dataMetricTimeField"
    )

    is_time_field = sgqlc.types.Field(Boolean, graphql_name="isTimeField")

    is_text_field = sgqlc.types.Field(Boolean, graphql_name="isTextField")

    is_numeric_field = sgqlc.types.Field(Boolean, graphql_name="isNumericField")

    is_boolean_field = sgqlc.types.Field(Boolean, graphql_name="isBooleanField")

    most_recent_use_in_same_table = sgqlc.types.Field(
        DateTime, graphql_name="mostRecentUseInSameTable"
    )

    most_recent_use_in_another_table = sgqlc.types.Field(
        DateTime, graphql_name="mostRecentUseInAnotherTable"
    )

    field_mcon = sgqlc.types.Field(String, graphql_name="fieldMcon")

    object_properties = sgqlc.types.Field(
        sgqlc.types.list_of(ObjectProperty), graphql_name="objectProperties"
    )

    object_metadata = sgqlc.types.Field(CatalogObjectMetadata, graphql_name="objectMetadata")


class TableMonitor(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "created_by",
        "last_update_user",
        "uuid",
        "account_uuid",
        "is_deleted",
        "deleted_at",
        "description",
        "notes",
        "is_template_managed",
        "namespace",
        "priority",
        "is_paused",
        "is_draft",
        "warehouse_uuid",
        "monitor_name",
        "deleted_by",
        "domain_restrictions",
        "asset_selection",
        "audiences",
        "failure_audiences",
        "alert_conditions",
        "tags",
        "data_quality_dimension",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    created_by = sgqlc.types.Field("User", graphql_name="createdBy")
    """Creator"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Last updated by"""

    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    account_uuid = sgqlc.types.Field(UUID, graphql_name="accountUuid")
    """Customer account id"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    description = sgqlc.types.Field(String, graphql_name="description")

    notes = sgqlc.types.Field(String, graphql_name="notes")

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )
    """Is this monitor managed by a configuration template (monitors-as-
    code)?
    """

    namespace = sgqlc.types.Field(String, graphql_name="namespace")
    """Namespace of rule, used for monitors-as-code"""

    priority = sgqlc.types.Field(TableMonitorModelPriority, graphql_name="priority")
    """Default priority for alerts involving this monitor"""

    is_paused = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPaused")
    """Is this monitor paused?"""

    is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft")
    """Is this a draft monitor?"""

    warehouse_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="warehouseUuid")

    monitor_name = sgqlc.types.Field(String, graphql_name="monitorName")
    """Name of monitor, must be unique per account, used for monitor
    identityresolution for monitors-as-code
    """

    deleted_by = sgqlc.types.Field("User", graphql_name="deletedBy")
    """Deleted by"""

    domain_restrictions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainRestrictions"
    )
    """List of domain UUIDs that need to be allowed to access this
    monitor, if any
    """

    asset_selection = sgqlc.types.Field(AssetSelection, graphql_name="assetSelection")
    """SQL blocks used on the monitor"""

    audiences = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="audiences"
    )
    """Monitor audiences"""

    failure_audiences = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="failureAudiences"
    )
    """The monitor notification audiences for failures"""

    alert_conditions = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableMonitorAlertCondition))),
        graphql_name="alertConditions",
    )

    tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(TagKeyValuePairOutput)), graphql_name="tags"
    )
    """The monitor tags."""

    data_quality_dimension = sgqlc.types.Field(String, graphql_name="dataQualityDimension")
    """Data quality dimension of the monitor."""


class TablePartitionKeys(sgqlc.types.Type, Node):
    """Information about the partition keys for a table"""

    __schema__ = schema
    __field_names__ = (
        "created_time",
        "updated_time",
        "mcon",
        "account",
        "keys",
        "template",
        "template_keys",
        "checksum",
    )
    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")

    mcon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mcon")

    account = sgqlc.types.Field(Account, graphql_name="account")

    keys = sgqlc.types.Field(JSONString, graphql_name="keys")
    """List of partition keys metadata"""

    template = sgqlc.types.Field(String, graphql_name="template")
    """Auto-generated predicate template"""

    template_keys = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="templateKeys"
    )
    """List of partition keys used in the template"""

    checksum = sgqlc.types.Field(String, graphql_name="checksum")
    """MD5 checksum used for incremental loading"""


class TableSchemaVersion(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = ("table", "version_id", "timestamp", "current_table", "fields")
    table = sgqlc.types.Field(sgqlc.types.non_null("WarehouseTable"), graphql_name="table")

    version_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="versionId")

    timestamp = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="timestamp")

    current_table = sgqlc.types.Field("WarehouseTable", graphql_name="currentTable")

    fields = sgqlc.types.Field(
        TableFieldConnection,
        graphql_name="fields",
        args=sgqlc.types.ArgDict(
            (
                ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)),
                (
                    "search_fields",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="searchFields", default=None
                    ),
                ),
                (
                    "is_time_field",
                    sgqlc.types.Arg(Boolean, graphql_name="isTimeField", default=None),
                ),
                (
                    "is_text_field",
                    sgqlc.types.Arg(Boolean, graphql_name="isTextField", default=None),
                ),
                (
                    "is_numeric_field",
                    sgqlc.types.Arg(Boolean, graphql_name="isNumericField", default=None),
                ),
                (
                    "is_boolean_field",
                    sgqlc.types.Arg(Boolean, graphql_name="isBooleanField", default=None),
                ),
                (
                    "suggest_time_axis",
                    sgqlc.types.Arg(Boolean, graphql_name="suggestTimeAxis", default=None),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("version", sgqlc.types.Arg(ID, graphql_name="version", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("field_type", sgqlc.types.Arg(String, graphql_name="fieldType", default=None)),
                ("mode", sgqlc.types.Arg(String, graphql_name="mode", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                (
                    "original_name",
                    sgqlc.types.Arg(String, graphql_name="originalName", default=None),
                ),
                (
                    "data_metric_time_field",
                    sgqlc.types.Arg(Boolean, graphql_name="dataMetricTimeField", default=None),
                ),
            )
        ),
    )
    """Arguments:

    * `search` (`String`)None
    * `search_fields` (`[String]`)None
    * `is_time_field` (`Boolean`)None
    * `is_text_field` (`Boolean`)None
    * `is_numeric_field` (`Boolean`)None
    * `is_boolean_field` (`Boolean`)None
    * `suggest_time_axis` (`Boolean`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `version` (`ID`)None
    * `name` (`String`)None
    * `field_type` (`String`)None
    * `mode` (`String`)None
    * `description` (`String`)None
    * `original_name` (`String`)None
    * `data_metric_time_field` (`Boolean`)None
    """


class TableStats(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "resource_uuid",
        "full_table_id",
        "project_name",
        "dataset_name",
        "table_name",
        "is_important",
        "importance_score",
        "avg_reads_per_active_day",
        "total_users",
        "degree_out",
        "avg_writes_per_active_day",
    )
    resource_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceUuid")

    full_table_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullTableId")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    dataset_name = sgqlc.types.Field(String, graphql_name="datasetName")

    table_name = sgqlc.types.Field(String, graphql_name="tableName")

    is_important = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isImportant")

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")

    avg_reads_per_active_day = sgqlc.types.Field(Float, graphql_name="avgReadsPerActiveDay")

    total_users = sgqlc.types.Field(Float, graphql_name="totalUsers")

    degree_out = sgqlc.types.Field(Float, graphql_name="degreeOut")

    avg_writes_per_active_day = sgqlc.types.Field(Float, graphql_name="avgWritesPerActiveDay")


class TableTag(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = ("table", "tag", "is_active")
    table = sgqlc.types.Field(sgqlc.types.non_null("WarehouseTable"), graphql_name="table")

    tag = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tag")

    is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive")


class TaskPerformanceSummary(sgqlc.types.Type, IEtlAssetPerformanceSummary):
    """ETL Task performance summary"""

    __schema__ = schema
    __field_names__ = ()


class UnifiedUser(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "account_id",
        "display_name",
        "created_time",
        "mc_user",
        "custom_user",
        "last_update_user",
        "last_update_time",
        "is_deleted",
        "unified_user_assignments",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")
    """UUID of unified user"""

    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """User-facing display name of user"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the object was first created"""

    mc_user = sgqlc.types.Field("User", graphql_name="mcUser")
    """Associated MC user"""

    custom_user = sgqlc.types.Field(CustomUser, graphql_name="customUser")
    """Associated custom user"""

    last_update_user = sgqlc.types.Field("User", graphql_name="lastUpdateUser")
    """Who last updated the object"""

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")
    """When the object was last updated"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    unified_user_assignments = sgqlc.types.Field(
        sgqlc.types.non_null(UnifiedUserAssignmentConnection),
        graphql_name="unifiedUserAssignments",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated MC user

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """


class UnifiedUserAssignment(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "account_id",
        "unified_user",
        "relationship_type",
        "created_time",
        "is_deleted",
        "object_mcon",
    )
    account_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountId")
    """Customer account id"""

    unified_user = sgqlc.types.Field(sgqlc.types.non_null(UnifiedUser), graphql_name="unifiedUser")
    """Associated MC user"""

    relationship_type = sgqlc.types.Field(
        UnifiedUserAssignmentModelRelationshipType, graphql_name="relationshipType"
    )
    """Type of relationship"""

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")
    """When the object was first created"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")
    """Is row deleted?"""

    object_mcon = sgqlc.types.Field(String, graphql_name="objectMcon")


class UpstreamDataRca(sgqlc.types.Type, IBaseRca, IQueryRca):
    __schema__ = schema
    __field_names__ = ("layer", "upstream_mcon")
    layer = sgqlc.types.Field(Int, graphql_name="layer")

    upstream_mcon = sgqlc.types.Field(String, graphql_name="upstreamMcon")
    """The mcon of the upstream change rca table"""


class User(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "cognito_user_id",
        "email",
        "first_name",
        "last_name",
        "display_name",
        "state",
        "created_on",
        "is_sso",
        "sso_groups",
        "sso_groups_updated_at",
        "token_id",
        "is_deleted",
        "deleted_at",
        "deleted_by",
        "delete_reason",
        "invalidated_at",
        "persona",
        "streamingsystemmodel_created_by",
        "streamingsystemmodel_updated_by",
        "streamingclustermodel_created_by",
        "streamingclustermodel_updated_by",
        "monitor_labels_created",
        "routing_rules_created_by",
        "routing_rules_updated_by",
        "notification_settings_added",
        "notification_settings_modified",
        "user_model_deleted_by",
        "user_settings",
        "invitees",
        "warehouse_deleted_by",
        "created_warehouses",
        "warehousemodel_updated_by",
        "bicontainermodel_created_by",
        "bicontainermodel_updated_by",
        "etlcontainermodel_created_by",
        "etlcontainermodel_updated_by",
        "connectionmodel_created_by",
        "connectionmodel_updated_by",
        "eventmodel_set",
        "eventdetectorfeedbackmodel_created_by",
        "eventdetectorfeedbackmodel_updated_by",
        "customsqltemplatemodel_created_by",
        "customsqltemplatemodel_updated_by",
        "datasourcemodel_created_by",
        "datasourcemodel_updated_by",
        "creator",
        "metricmonitoringmodel_set",
        "customrulequerymodel_created_by",
        "customrulequerymodel_updated_by",
        "table_monitors_deleted_by",
        "tablemonitormodel_created_by",
        "tablemonitormodel_updated_by",
        "object_properties",
        "catalog_object_metadata",
        "resources",
        "monte_carlo_config_templates",
        "domain_created_by",
        "alationintegrationmodel_created_by",
        "alationintegrationmodel_updated_by",
        "slack_credentials_v2",
        "custom_users",
        "unified_users",
        "last_updated_unified_users",
        "collection_preference_created_by",
        "collection_preference_last_updated_by",
        "collection_preference_deleted_by",
        "asset_collection_preference_created_by",
        "asset_collection_preference_last_updated_by",
        "data_product_created_by",
        "data_product_last_updated_by",
        "data_product_deleted_by",
        "tutorial_user",
        "opsgenieintegrationmodel_created_by",
        "opsgenieintegrationmodel_updated_by",
        "collibra_integration_created_by",
        "collibraintegrationmodel_updated_by",
        "monitoredtablerulemodel_created_by",
        "monitoredtablerulemodel_updated_by",
        "customdashboardmodel_created_by",
        "customdashboardmodel_updated_by",
        "dataexplorerdashboardmodel_created_by",
        "dataexplorerdashboardmodel_updated_by",
        "dataexplorercomparisondashboardmodel_created_by",
        "dataexplorercomparisondashboardmodel_updated_by",
        "dataexplorerwidgetmodel_created_by",
        "dataexplorerwidgetmodel_updated_by",
        "lineage_block_patterns",
        "lineage_repl_rules",
        "lineagenodecollapsingpatternmodel_created_by",
        "lineagenodecollapsingpatternmodel_updated_by",
        "account",
        "role",
        "auth",
        "allowed_connections",
    )
    cognito_user_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cognitoUserId")

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")

    first_name = sgqlc.types.Field(String, graphql_name="firstName")

    last_name = sgqlc.types.Field(String, graphql_name="lastName")

    display_name = sgqlc.types.Field(String, graphql_name="displayName")
    """Text to use when displaying the user."""

    state = sgqlc.types.Field(sgqlc.types.non_null(UserModelState), graphql_name="state")

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    is_sso = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSso")

    sso_groups = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="ssoGroups"
    )
    """Groups provided by the IdP in the last login"""

    sso_groups_updated_at = sgqlc.types.Field(DateTime, graphql_name="ssoGroupsUpdatedAt")
    """Last time the SSO groups where updated"""

    token_id = sgqlc.types.Field(String, graphql_name="tokenId")
    """For role=service accounts, the associated API token ID"""

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")
    """Timestamp the user was soft deleted at"""

    deleted_by = sgqlc.types.Field("User", graphql_name="deletedBy")

    delete_reason = sgqlc.types.Field(UserModelDeleteReason, graphql_name="deleteReason")
    """Reason the user was soft deleted"""

    invalidated_at = sgqlc.types.Field(DateTime, graphql_name="invalidatedAt")
    """Indicates if a user has been invalidated, and when the
    invalidation occurred
    """

    persona = sgqlc.types.Field(UserModelPersona, graphql_name="persona")
    """Each user has a persona that can help personalize the home page
    experience and the onboarding flow.
    """

    streamingsystemmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingSystem))),
        graphql_name="streamingsystemmodelCreatedBy",
    )
    """Creator"""

    streamingsystemmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingSystem))),
        graphql_name="streamingsystemmodelUpdatedBy",
    )
    """Last updated by"""

    streamingclustermodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingCluster))),
        graphql_name="streamingclustermodelCreatedBy",
    )
    """Creator"""

    streamingclustermodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(StreamingCluster))),
        graphql_name="streamingclustermodelUpdatedBy",
    )
    """Last updated by"""

    monitor_labels_created = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorLabelObject))),
        graphql_name="monitorLabelsCreated",
    )
    """Monitor label creator"""

    routing_rules_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationRoutingRule))),
        graphql_name="routingRulesCreatedBy",
    )
    """Creator of the routing rule"""

    routing_rules_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationRoutingRule))),
        graphql_name="routingRulesUpdatedBy",
    )
    """Routing rule last updated by"""

    notification_settings_added = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationSetting))),
        graphql_name="notificationSettingsAdded",
    )
    """Creator of the notification"""

    notification_settings_modified = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(NotificationSetting))),
        graphql_name="notificationSettingsModified",
    )
    """User who last updated this notification"""

    user_model_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(UserConnection),
        graphql_name="userModelDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("email", sgqlc.types.Arg(String, graphql_name="email", default=None)),
                ("first_name", sgqlc.types.Arg(String, graphql_name="firstName", default=None)),
                ("last_name", sgqlc.types.Arg(String, graphql_name="lastName", default=None)),
                ("role", sgqlc.types.Arg(String, graphql_name="role", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `email` (`String`)None
    * `first_name` (`String`)None
    * `last_name` (`String`)None
    * `role` (`String`)None
    """

    user_settings = sgqlc.types.Field(
        sgqlc.types.non_null(UserSettingsConnection),
        graphql_name="userSettings",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated user

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    invitees = sgqlc.types.Field(
        sgqlc.types.non_null(UserInviteConnection),
        graphql_name="invitees",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("state", sgqlc.types.Arg(String, graphql_name="state", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `state` (`String`)None
    """

    warehouse_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warehouse))),
        graphql_name="warehouseDeletedBy",
    )

    created_warehouses = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warehouse))),
        graphql_name="createdWarehouses",
    )
    """User who created this warehouse"""

    warehousemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warehouse))),
        graphql_name="warehousemodelUpdatedBy",
    )
    """Last updated by"""

    bicontainermodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(BiContainer))),
        graphql_name="bicontainermodelCreatedBy",
    )
    """Creator"""

    bicontainermodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(BiContainer))),
        graphql_name="bicontainermodelUpdatedBy",
    )
    """Last updated by"""

    etlcontainermodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(EtlContainer))),
        graphql_name="etlcontainermodelCreatedBy",
    )
    """Creator"""

    etlcontainermodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(EtlContainer))),
        graphql_name="etlcontainermodelUpdatedBy",
    )
    """Last updated by"""

    connectionmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connectionmodelCreatedBy",
    )
    """Creator"""

    connectionmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="connectionmodelUpdatedBy",
    )
    """Last updated by"""

    eventmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="eventmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    eventdetectorfeedbackmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(EventDetectorFeedbackConnection),
        graphql_name="eventdetectorfeedbackmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    eventdetectorfeedbackmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(EventDetectorFeedbackConnection),
        graphql_name="eventdetectorfeedbackmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    customsqltemplatemodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomSQLTemplateConnection),
        graphql_name="customsqltemplatemodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("sql_template", sgqlc.types.Arg(String, graphql_name="sqlTemplate", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        CustomSQLTemplateModelQueryResultType,
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `name` (`String`)None
    * `description` (`String`)None
    * `sql_template` (`String`)None
    * `dialect` (`String`)None
    * `query_result_type`
      (`CustomSQLTemplateModelQueryResultType`)None
    """

    customsqltemplatemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomSQLTemplateConnection),
        graphql_name="customsqltemplatemodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)),
                ("description", sgqlc.types.Arg(String, graphql_name="description", default=None)),
                ("sql_template", sgqlc.types.Arg(String, graphql_name="sqlTemplate", default=None)),
                ("dialect", sgqlc.types.Arg(String, graphql_name="dialect", default=None)),
                (
                    "query_result_type",
                    sgqlc.types.Arg(
                        CustomSQLTemplateModelQueryResultType,
                        graphql_name="queryResultType",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `name` (`String`)None
    * `description` (`String`)None
    * `sql_template` (`String`)None
    * `dialect` (`String`)None
    * `query_result_type`
      (`CustomSQLTemplateModelQueryResultType`)None
    """

    datasourcemodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorDataSource))),
        graphql_name="datasourcemodelCreatedBy",
    )
    """Creator"""

    datasourcemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorDataSource))),
        graphql_name="datasourcemodelUpdatedBy",
    )
    """Last updated by"""

    creator = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonMonitorResponseConnection),
        graphql_name="creator",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Who added the monitor

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    metricmonitoringmodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonMonitorResponseConnection),
        graphql_name="metricmonitoringmodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Who was the last user to update the monitor

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    customrulequerymodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleQueryConnection),
        graphql_name="customrulequerymodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    customrulequerymodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomRuleQueryConnection),
        graphql_name="customrulequerymodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    table_monitors_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(TableMonitorConnection),
        graphql_name="tableMonitorsDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Deleted by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tablemonitormodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(TableMonitorConnection),
        graphql_name="tablemonitormodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tablemonitormodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(TableMonitorConnection),
        graphql_name="tablemonitormodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    object_properties = sgqlc.types.Field(
        sgqlc.types.non_null(ObjectPropertyConnection),
        graphql_name="objectProperties",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("mcon_id", sgqlc.types.Arg(String, graphql_name="mconId", default=None)),
            )
        ),
    )
    """Who last updated the property

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `mcon_id` (`String`)None
    """

    catalog_object_metadata = sgqlc.types.Field(
        sgqlc.types.non_null(CatalogObjectMetadataConnection),
        graphql_name="catalogObjectMetadata",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("mcon", sgqlc.types.Arg(String, graphql_name="mcon", default=None)),
            )
        ),
    )
    """Who last updated the object

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `mcon` (`String`)None
    """

    resources = sgqlc.types.Field(
        sgqlc.types.non_null(ResourceConnection),
        graphql_name="resources",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Who last updated the resource

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    monte_carlo_config_templates = sgqlc.types.Field(
        sgqlc.types.non_null(MonteCarloConfigTemplateConnection),
        graphql_name="monteCarloConfigTemplates",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("namespace", sgqlc.types.Arg(String, graphql_name="namespace", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `namespace` (`String`)None
    """

    domain_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DomainRestrictionConnection),
        graphql_name="domainCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    alationintegrationmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(AlationIntegrationConnection),
        graphql_name="alationintegrationmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    alationintegrationmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(AlationIntegrationConnection),
        graphql_name="alationintegrationmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    slack_credentials_v2 = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(SlackCredentialsV2))),
        graphql_name="slackCredentialsV2",
    )
    """User that installed the Slack app"""

    custom_users = sgqlc.types.Field(
        sgqlc.types.non_null(CustomUserConnection),
        graphql_name="customUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Who last updated the object

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    unified_users = sgqlc.types.Field(
        sgqlc.types.non_null(UnifiedUserConnection),
        graphql_name="unifiedUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated MC user

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    last_updated_unified_users = sgqlc.types.Field(
        sgqlc.types.non_null(UnifiedUserConnection),
        graphql_name="lastUpdatedUnifiedUsers",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Who last updated the object

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collection_preference_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferenceCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collection_preference_last_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferenceLastUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collection_preference_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollectionBlockConnection),
        graphql_name="collectionPreferenceDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    asset_collection_preference_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionPreferencesConnection),
        graphql_name="assetCollectionPreferenceCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    asset_collection_preference_last_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(AssetCollectionPreferencesConnection),
        graphql_name="assetCollectionPreferenceLastUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_last_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductLastUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_product_deleted_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataProductConnection),
        graphql_name="dataProductDeletedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    tutorial_user = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(UserTutorial))),
        graphql_name="tutorialUser",
    )
    """The user which the tutorial step is relevant for"""

    opsgenieintegrationmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(OpsgenieIntegrationOutput))),
        graphql_name="opsgenieintegrationmodelCreatedBy",
    )
    """Creator"""

    opsgenieintegrationmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(OpsgenieIntegrationOutput))),
        graphql_name="opsgenieintegrationmodelUpdatedBy",
    )
    """Last updated by"""

    collibra_integration_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollibraIntegrationConnection),
        graphql_name="collibraIntegrationCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    collibraintegrationmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CollibraIntegrationConnection),
        graphql_name="collibraintegrationmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    monitoredtablerulemodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitoredTableRuleObject))),
        graphql_name="monitoredtablerulemodelCreatedBy",
    )
    """Creator"""

    monitoredtablerulemodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitoredTableRuleObject))),
        graphql_name="monitoredtablerulemodelUpdatedBy",
    )
    """Last updated by"""

    customdashboardmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardConnection),
        graphql_name="customdashboardmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    customdashboardmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(CustomDashboardConnection),
        graphql_name="customdashboardmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerdashboardmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerDashboardTypeConnection),
        graphql_name="dataexplorerdashboardmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerdashboardmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerDashboardTypeConnection),
        graphql_name="dataexplorerdashboardmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorercomparisondashboardmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerComparisonDashboardTypeConnection),
        graphql_name="dataexplorercomparisondashboardmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorercomparisondashboardmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerComparisonDashboardTypeConnection),
        graphql_name="dataexplorercomparisondashboardmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerwidgetmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerWidgetTypeConnection),
        graphql_name="dataexplorerwidgetmodelCreatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Creator

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dataexplorerwidgetmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(DataExplorerWidgetTypeConnection),
        graphql_name="dataexplorerwidgetmodelUpdatedBy",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Last updated by

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    lineage_block_patterns = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeBlockPattern))),
        graphql_name="lineageBlockPatterns",
    )
    """Who last updated the regexp"""

    lineage_repl_rules = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeReplacementRule))),
        graphql_name="lineageReplRules",
    )
    """Who last updated the replacement rule"""

    lineagenodecollapsingpatternmodel_created_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeCollapsingRule))),
        graphql_name="lineagenodecollapsingpatternmodelCreatedBy",
    )
    """Creator"""

    lineagenodecollapsingpatternmodel_updated_by = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LineageNodeCollapsingRule))),
        graphql_name="lineagenodecollapsingpatternmodelUpdatedBy",
    )
    """Last updated by"""

    account = sgqlc.types.Field(Account, graphql_name="account")

    role = sgqlc.types.Field(String, graphql_name="role")
    """User internal role. One of:  user, service, system. Check the
    user's groups for their authorization roles
    """

    auth = sgqlc.types.Field(UserAuthorizationOutput, graphql_name="auth")
    """User's aggregate authorization policy."""

    allowed_connections = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Connection))),
        graphql_name="allowedConnections",
    )
    """Connections this user is allowed to use. Empty means unrestricted."""


class UserBasicInfo(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = ("email", "first_name", "last_name")
    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")

    first_name = sgqlc.types.Field(String, graphql_name="firstName")

    last_name = sgqlc.types.Field(String, graphql_name="lastName")


class UserDefinedMonitorV2(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "creator_id",
        "monitor_type",
        "name",
        "account_uuid",
        "udm_type",
        "resource_id",
        "updater_id",
        "entities",
        "projects",
        "datasets",
        "comparisons",
        "rule_comparisons",
        "rule_description",
        "rule_variables",
        "monitor_fields",
        "monitor_time_axis_field_name",
        "monitor_time_axis_field_type",
        "created_time",
        "last_update_time",
        "schedule_type",
        "last_run",
        "interval_in_seconds",
        "prev_execution_time",
        "next_execution_time",
        "is_deleted",
        "is_template_managed",
        "is_snoozeable",
        "is_snoozed",
        "conditional_snooze",
        "snooze_until_time",
        "is_paused",
        "is_draft",
        "where_condition",
        "use_partition_clause",
        "namespace",
        "rule_name",
        "rule_notes",
        "history_days",
        "segmented_expressions",
        "interval_minutes",
        "agg_time_interval",
        "severity",
        "priority",
        "high_segment_count",
        "data_source_id",
        "source_data_source_id",
        "segmentation_type",
        "consolidated_monitor_status",
        "exceptions",
        "breached",
        "alert_ids",
        "invalid_rows",
        "domain_restrictions",
        "monitor_sql_blocks",
        "sampling_config",
        "entity_mcons",
        "agent_span_filters",
        "filters",
        "has_custom_rule_name",
        "is_transitioning_data_provider",
        "notify_rule_run_failure",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    creator_id = sgqlc.types.Field(String, graphql_name="creatorId")
    """The email of the user that created the monitor"""

    monitor_type = sgqlc.types.Field(
        sgqlc.types.non_null(UserDefinedMonitorModelMonitorType), graphql_name="monitorType"
    )

    name = sgqlc.types.Field(String, graphql_name="name")

    account_uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="accountUuid")
    """The account uuid"""

    udm_type = sgqlc.types.Field(
        sgqlc.types.non_null(UserDefinedMonitorModelUdmType), graphql_name="udmType"
    )

    resource_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="resourceId")

    updater_id = sgqlc.types.Field(String, graphql_name="updaterId")
    """The email of the user that last updated the monitor"""

    entities = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entities"
    )
    """Tables associated with monitor"""

    projects = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="projects"
    )
    """Projects associated with monitor"""

    datasets = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="datasets"
    )
    """Datasets associated with monitor"""

    comparisons = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(CustomRuleComparison)), graphql_name="comparisons"
    )
    """Metric evaluator configuration"""

    rule_comparisons = sgqlc.types.Field(
        sgqlc.types.list_of(CustomRuleComparison), graphql_name="ruleComparisons"
    )
    """Deprecated in favor of comparisons"""

    rule_description = sgqlc.types.Field(String, graphql_name="ruleDescription")

    rule_variables = sgqlc.types.Field(JSONString, graphql_name="ruleVariables")

    monitor_fields = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="monitorFields"
    )

    monitor_time_axis_field_name = sgqlc.types.Field(
        String, graphql_name="monitorTimeAxisFieldName"
    )

    monitor_time_axis_field_type = sgqlc.types.Field(
        String, graphql_name="monitorTimeAxisFieldType"
    )

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    last_update_time = sgqlc.types.Field(DateTime, graphql_name="lastUpdateTime")

    schedule_type = sgqlc.types.Field(
        UserDefinedMonitorModelScheduleType, graphql_name="scheduleType"
    )

    last_run = sgqlc.types.Field(DateTime, graphql_name="lastRun")

    interval_in_seconds = sgqlc.types.Field(Int, graphql_name="intervalInSeconds")

    prev_execution_time = sgqlc.types.Field(DateTime, graphql_name="prevExecutionTime")

    next_execution_time = sgqlc.types.Field(DateTime, graphql_name="nextExecutionTime")

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    is_template_managed = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isTemplateManaged"
    )

    is_snoozeable = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSnoozeable")

    is_snoozed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSnoozed")

    conditional_snooze = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="conditionalSnooze"
    )

    snooze_until_time = sgqlc.types.Field(DateTime, graphql_name="snoozeUntilTime")

    is_paused = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPaused")

    is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft")

    where_condition = sgqlc.types.Field(String, graphql_name="whereCondition")

    use_partition_clause = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="usePartitionClause"
    )

    namespace = sgqlc.types.Field(String, graphql_name="namespace")

    rule_name = sgqlc.types.Field(String, graphql_name="ruleName")
    """Deprecated in favor of name which also provides names for monitors"""

    rule_notes = sgqlc.types.Field(String, graphql_name="ruleNotes")

    history_days = sgqlc.types.Field(Int, graphql_name="historyDays")
    """How many days to look back when fetching recent metrics. When
    using a timestamp field to select recent metrics, set to 0 to look
    back since last execution. If not provided, a default look back of
    1 day will be used.When using a date field to select recent
    metris, a minimum of 3 days will be used.
    """

    segmented_expressions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="segmentedExpressions"
    )
    """Fields or expressions to segment by"""

    interval_minutes = sgqlc.types.Field(Int, graphql_name="intervalMinutes")

    agg_time_interval = sgqlc.types.Field(String, graphql_name="aggTimeInterval")

    severity = sgqlc.types.Field(String, graphql_name="severity")

    priority = sgqlc.types.Field(String, graphql_name="priority")

    high_segment_count = sgqlc.types.Field(Boolean, graphql_name="highSegmentCount")
    """Flag to apply additional limits which increase the supported
    segment count
    """

    data_source_id = sgqlc.types.Field(Int, graphql_name="dataSourceId")

    source_data_source_id = sgqlc.types.Field(Int, graphql_name="sourceDataSourceId")

    segmentation_type = sgqlc.types.Field(
        UserDefinedMonitorModelSegmentationType, graphql_name="segmentationType"
    )
    """The type of segmentation specified in segmented_expressions. For
    instance field or custom_sql_expression.
    """

    consolidated_monitor_status = sgqlc.types.Field(
        UserDefinedMonitorModelConsolidatedMonitorStatus, graphql_name="consolidatedMonitorStatus"
    )
    """Consolidated status for the monitor."""

    exceptions = sgqlc.types.Field(String, graphql_name="exceptions")
    """Exceptions happened on the monitor execution."""

    breached = sgqlc.types.Field(UserDefinedMonitorModelBreached, graphql_name="breached")
    """Monitor breached status."""

    alert_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="alertIds"
    )
    """Alert ids"""

    invalid_rows = sgqlc.types.Field(Int, graphql_name="invalidRows")
    """Total invalid fields count."""

    domain_restrictions = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(UUID)), graphql_name="domainRestrictions"
    )
    """List of domain UUIDs that need to be allowed to access this
    monitor, if any
    """

    monitor_sql_blocks = sgqlc.types.Field(JSONString, graphql_name="monitorSqlBlocks")
    """Structured SQL filtering from monitors"""

    sampling_config = sgqlc.types.Field(MonitorSamplingConfig, graphql_name="samplingConfig")
    """Sampling configuration"""

    entity_mcons = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="entityMcons")
    """MCONs for monitored tables/views"""

    agent_span_filters = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AgentSpanFilter)), graphql_name="agentSpanFilters"
    )
    """agent span filters used on the monitor"""

    filters = sgqlc.types.Field(FilterGroup, graphql_name="filters")
    """filters used on the monitor"""

    has_custom_rule_name = sgqlc.types.Field(Boolean, graphql_name="hasCustomRuleName")

    is_transitioning_data_provider = sgqlc.types.Field(
        Boolean, graphql_name="isTransitioningDataProvider"
    )

    notify_rule_run_failure = sgqlc.types.Field(Boolean, graphql_name="notifyRuleRunFailure")
    """DEPRECATED: Replaced by failure audiences"""


class UserInvite(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "uuid",
        "email",
        "state",
        "account",
        "created_by",
        "created_on",
        "accepted_on",
        "role",
        "auth_groups",
        "invite_type",
        "last_sent_time",
        "attempts",
        "user_previous_account",
        "expires_at",
    )
    uuid = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="uuid")

    email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email")

    state = sgqlc.types.Field(sgqlc.types.non_null(UserInviteModelState), graphql_name="state")

    account = sgqlc.types.Field(sgqlc.types.non_null(Account), graphql_name="account")

    created_by = sgqlc.types.Field(sgqlc.types.non_null(User), graphql_name="createdBy")

    created_on = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdOn")

    accepted_on = sgqlc.types.Field(DateTime, graphql_name="acceptedOn")

    role = sgqlc.types.Field(String, graphql_name="role")
    """Deprecated. Use auth groups going forward. Will remove after
    migration.
    """

    auth_groups = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="authGroups"
    )
    """List of auth group names to put user in on invite acceptance"""

    invite_type = sgqlc.types.Field(UserInviteModelInviteType, graphql_name="inviteType")
    """Type of invitation."""

    last_sent_time = sgqlc.types.Field(DateTime, graphql_name="lastSentTime")
    """Last time this invite was sent"""

    attempts = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="attempts")
    """Number of times invite verification has been attempted with the
    current token
    """

    user_previous_account = sgqlc.types.Field(Account, graphql_name="userPreviousAccount")

    expires_at = sgqlc.types.Field(DateTime, graphql_name="expiresAt")
    """Expiration of this invite"""


class UserSettings(sgqlc.types.Type, Node):
    """User settings stored associated with the key."""

    __schema__ = schema
    __field_names__ = ("user", "key", "value", "created_time", "updated_time", "description")
    user = sgqlc.types.Field(sgqlc.types.non_null(User), graphql_name="user")
    """Associated user"""

    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")

    value = sgqlc.types.Field(JSONString, graphql_name="value")

    created_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdTime")
    """When the user-specific setting was first created"""

    updated_time = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedTime")
    """When the user-specific setting was last updated"""

    description = sgqlc.types.Field(String, graphql_name="description")
    """A brief description of the user settings."""


class WarehouseTable(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "table_id",
        "full_table_id",
        "warehouse",
        "discovered_time",
        "friendly_name",
        "location",
        "project_name",
        "dataset",
        "description",
        "table_type",
        "is_encrypted",
        "created_time",
        "last_modified",
        "view_query",
        "view_is_materialized",
        "labels",
        "path",
        "priority",
        "tracked",
        "dynamic_table",
        "is_deleted",
        "deleted_at",
        "last_observed",
        "is_excluded",
        "is_monitored",
        "data_provider",
        "mcon",
        "importance_score",
        "is_important",
        "last_activity",
        "last_read",
        "last_write",
        "last_volume_change",
        "importance_score_is_custom",
        "is_important_is_custom",
        "anomalies",
        "tags",
        "versions",
        "events",
        "events_though_event_assets",
        "data_source_tables",
        "monitors",
        "object_properties",
        "domains",
        "dbt_nodes",
        "dbt_run_steps",
        "fivetranconnectormodel_set",
        "agent_trace_tables",
        "thresholds",
        "get_thresholds",
        "freshness_anomaly",
        "size_anomaly",
        "freshness_size_anomaly",
        "metric_anomaly",
        "status",
        "schema_change_count",
        "status_scalar",
        "node_id",
        "is_partial_date_range",
        "freshness_collection_status",
        "volume_collection_status",
        "is_muted",
        "muted_event_types",
        "table_stats",
        "is_transitioning_data_provider",
        "table_capabilities",
        "partition_keys",
        "total_downstream_nodes",
        "total_upstream_nodes",
        "monitored_metrics",
        "table_monitor_count",
    )
    table_id = sgqlc.types.Field(String, graphql_name="tableId")

    full_table_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullTableId")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")

    discovered_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="discoveredTime"
    )

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")

    location = sgqlc.types.Field(String, graphql_name="location")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    dataset = sgqlc.types.Field(String, graphql_name="dataset")

    description = sgqlc.types.Field(String, graphql_name="description")
    """(Deprecated) Use `description` from `CatalogObjectMetadataModel`"""

    table_type = sgqlc.types.Field(String, graphql_name="tableType")

    is_encrypted = sgqlc.types.Field(Boolean, graphql_name="isEncrypted")

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    last_modified = sgqlc.types.Field(DateTime, graphql_name="lastModified")

    view_query = sgqlc.types.Field(String, graphql_name="viewQuery")

    view_is_materialized = sgqlc.types.Field(Boolean, graphql_name="viewIsMaterialized")

    labels = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels"
    )

    path = sgqlc.types.Field(String, graphql_name="path")

    priority = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="priority")

    tracked = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="tracked")

    dynamic_table = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="dynamicTable")

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    last_observed = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="lastObserved")

    is_excluded = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExcluded")

    is_monitored = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isMonitored")
    """Is table monitored? Source of truth for table-based pricing"""

    data_provider = sgqlc.types.Field(String, graphql_name="dataProvider")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")
    """The table's MCON (MC Object Name)"""

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")

    last_activity = sgqlc.types.Field(DateTime, graphql_name="lastActivity")

    last_read = sgqlc.types.Field(DateTime, graphql_name="lastRead")

    last_write = sgqlc.types.Field(DateTime, graphql_name="lastWrite")

    last_volume_change = sgqlc.types.Field(DateTime, graphql_name="lastVolumeChange")

    importance_score_is_custom = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="importanceScoreIsCustom"
    )

    is_important_is_custom = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isImportantIsCustom"
    )

    anomalies = sgqlc.types.Field(
        TableAnomalyConnection,
        graphql_name="anomalies",
        args=sgqlc.types.ArgDict(
            (
                (
                    "reasons",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="reasons", default=None
                    ),
                ),
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("uuid", sgqlc.types.Arg(UUID, graphql_name="uuid", default=None)),
                ("unique_key", sgqlc.types.Arg(String, graphql_name="uniqueKey", default=None)),
                ("grouping_key", sgqlc.types.Arg(String, graphql_name="groupingKey", default=None)),
                (
                    "job_execution_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="jobExecutionUuid", default=None),
                ),
                (
                    "consolidating_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="consolidatingUuid", default=None),
                ),
                (
                    "warehouse_uuid",
                    sgqlc.types.Arg(UUID, graphql_name="warehouseUuid", default=None),
                ),
                ("table", sgqlc.types.Arg(ID, graphql_name="table", default=None)),
                ("rule_uuid", sgqlc.types.Arg(UUID, graphql_name="ruleUuid", default=None)),
                ("anomaly_id", sgqlc.types.Arg(String, graphql_name="anomalyId", default=None)),
                ("detected_on", sgqlc.types.Arg(DateTime, graphql_name="detectedOn", default=None)),
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                ("is_active", sgqlc.types.Arg(Boolean, graphql_name="isActive", default=None)),
                (
                    "is_false_positive",
                    sgqlc.types.Arg(Boolean, graphql_name="isFalsePositive", default=None),
                ),
                ("reason", sgqlc.types.Arg(String, graphql_name="reason", default=None)),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """Arguments:

    * `reasons` (`[String]`)None
    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `uuid` (`UUID`)None
    * `unique_key` (`String`)None
    * `grouping_key` (`String`)None
    * `job_execution_uuid` (`UUID`)None
    * `consolidating_uuid` (`UUID`)None
    * `warehouse_uuid` (`UUID`)None
    * `table` (`ID`)None
    * `rule_uuid` (`UUID`)None
    * `anomaly_id` (`String`)None
    * `detected_on` (`DateTime`)None
    * `start_time` (`DateTime`)None
    * `end_time` (`DateTime`)None
    * `is_active` (`Boolean`)None
    * `is_false_positive` (`Boolean`)None
    * `reason` (`String`)None
    * `order_by` (`String`): Ordering
    """

    tags = sgqlc.types.Field(
        sgqlc.types.non_null(TableTagConnection),
        graphql_name="tags",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    versions = sgqlc.types.Field(
        TableSchemaVersionConnection,
        graphql_name="versions",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("table", sgqlc.types.Arg(ID, graphql_name="table", default=None)),
                ("version_id", sgqlc.types.Arg(String, graphql_name="versionId", default=None)),
                ("timestamp", sgqlc.types.Arg(DateTime, graphql_name="timestamp", default=None)),
                ("order_by", sgqlc.types.Arg(String, graphql_name="orderBy", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `table` (`ID`)None
    * `version_id` (`String`)None
    * `timestamp` (`DateTime`)None
    * `order_by` (`String`): Ordering
    """

    events = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="events",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    events_though_event_assets = sgqlc.types.Field(
        sgqlc.types.non_null(EventConnection),
        graphql_name="eventsThoughEventAssets",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """See note in EventAssetModel.table before using

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    data_source_tables = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(MonitorDataSource))),
        graphql_name="dataSourceTables",
    )
    """Tables referenced by the data source"""

    monitors = sgqlc.types.Field(
        sgqlc.types.non_null(ComparisonMonitorResponseConnection),
        graphql_name="monitors",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
                ("type", sgqlc.types.Arg(String, graphql_name="type", default=None)),
            )
        ),
    )
    """Table related to monitor

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    * `type` (`String`)None
    """

    object_properties = sgqlc.types.Field(
        sgqlc.types.list_of(ObjectProperty), graphql_name="objectProperties"
    )

    domains = sgqlc.types.Field(
        sgqlc.types.non_null(DomainRestrictionConnection),
        graphql_name="domains",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dbt_nodes = sgqlc.types.Field(
        sgqlc.types.non_null(DbtNodeConnection),
        graphql_name="dbtNodes",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated table

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    dbt_run_steps = sgqlc.types.Field(
        sgqlc.types.non_null(DbtRunStepConnection),
        graphql_name="dbtRunSteps",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Associated table

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    fivetranconnectormodel_set = sgqlc.types.Field(
        sgqlc.types.non_null(FivetranConnectorConnection),
        graphql_name="fivetranconnectormodelSet",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    agent_trace_tables = sgqlc.types.Field(
        sgqlc.types.non_null(AgentTraceTableConnection),
        graphql_name="agentTraceTables",
        args=sgqlc.types.ArgDict(
            (
                ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)),
                ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)),
                ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)),
                ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)),
                ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)),
            )
        ),
    )
    """Agent trace table

    Arguments:

    * `offset` (`Int`)None
    * `before` (`String`)None
    * `after` (`String`)None
    * `first` (`Int`)None
    * `last` (`Int`)None
    """

    thresholds = sgqlc.types.Field(ThresholdsData, graphql_name="thresholds")
    """Section describing various anomaly thresholds for the table"""

    get_thresholds = sgqlc.types.Field(ThresholdsData, graphql_name="getThresholds")
    """Section describing various anomaly thresholds for the table"""

    freshness_anomaly = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="freshnessAnomaly"
    )
    """DEPRECATED"""

    size_anomaly = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="sizeAnomaly")
    """DEPRECATED"""

    freshness_size_anomaly = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="freshnessSizeAnomaly"
    )
    """DEPRECATED"""

    metric_anomaly = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="metricAnomaly")
    """DEPRECATED"""

    status = sgqlc.types.Field(WarehouseTableModelStatus, graphql_name="status")
    """DEPRECATED"""

    schema_change_count = sgqlc.types.Field(Int, graphql_name="schemaChangeCount")

    status_scalar = sgqlc.types.Field(Int, graphql_name="statusScalar")

    node_id = sgqlc.types.Field(String, graphql_name="nodeId")

    is_partial_date_range = sgqlc.types.Field(
        Boolean,
        graphql_name="isPartialDateRange",
        args=sgqlc.types.ArgDict(
            (
                ("start_time", sgqlc.types.Arg(DateTime, graphql_name="startTime", default=None)),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
            )
        ),
    )
    """Arguments:

    * `start_time` (`DateTime`)None
    * `end_time` (`DateTime`)None
    """

    freshness_collection_status = sgqlc.types.Field(
        TableCollectionStatus, graphql_name="freshnessCollectionStatus"
    )
    """(experimental) DEPRECATED. Return the freshness collection status
    for the asset
    """

    volume_collection_status = sgqlc.types.Field(
        TableCollectionStatus, graphql_name="volumeCollectionStatus"
    )
    """(experimental) DEPRECATED. Return the volume collection status for
    the asset
    """

    is_muted = sgqlc.types.Field(Boolean, graphql_name="isMuted")
    """No incidents will be created for this table if muted."""

    muted_event_types = sgqlc.types.Field(
        sgqlc.types.list_of(MutedEventType), graphql_name="mutedEventTypes"
    )
    """Muting is active for the specified event types."""

    table_stats = sgqlc.types.Field(TableStats, graphql_name="tableStats")
    """Stats for the table"""

    is_transitioning_data_provider = sgqlc.types.Field(
        Boolean, graphql_name="isTransitioningDataProvider"
    )

    table_capabilities = sgqlc.types.Field(
        TableCapabilitiesResponse, graphql_name="tableCapabilities"
    )
    """Capabilities for the table"""

    partition_keys = sgqlc.types.Field(TablePartitionKeys, graphql_name="partitionKeys")
    """Partition key information"""

    total_downstream_nodes = sgqlc.types.Field(Int, graphql_name="totalDownstreamNodes")
    """Downstream nodes count"""

    total_upstream_nodes = sgqlc.types.Field(Int, graphql_name="totalUpstreamNodes")
    """Upstream nodes count"""

    monitored_metrics = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="monitoredMetrics",
    )

    table_monitor_count = sgqlc.types.Field(Int, graphql_name="tableMonitorCount")
    """Number of table monitors covering this table (eventually
    consistent)
    """


class WarehouseTableHealth(sgqlc.types.Type, Node):
    __schema__ = schema
    __field_names__ = (
        "table_id",
        "full_table_id",
        "warehouse",
        "discovered_time",
        "friendly_name",
        "location",
        "project_name",
        "dataset",
        "description",
        "table_type",
        "is_encrypted",
        "created_time",
        "last_modified",
        "view_query",
        "view_is_materialized",
        "labels",
        "path",
        "priority",
        "tracked",
        "dynamic_table",
        "is_deleted",
        "deleted_at",
        "last_observed",
        "is_excluded",
        "is_monitored",
        "data_provider",
        "mcon",
        "importance_score",
        "is_important",
        "last_activity",
        "last_read",
        "last_write",
        "last_volume_change",
        "importance_score_is_custom",
        "is_important_is_custom",
        "freshness_anomaly",
        "size_anomaly",
        "freshness_size_anomaly",
        "metric_anomaly",
        "status",
        "tags",
        "categories_with_monitors",
        "categories_with_monitor_counts",
        "incidents",
        "table_capabilities",
    )
    table_id = sgqlc.types.Field(String, graphql_name="tableId")

    full_table_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullTableId")

    warehouse = sgqlc.types.Field(sgqlc.types.non_null(Warehouse), graphql_name="warehouse")

    discovered_time = sgqlc.types.Field(
        sgqlc.types.non_null(DateTime), graphql_name="discoveredTime"
    )

    friendly_name = sgqlc.types.Field(String, graphql_name="friendlyName")

    location = sgqlc.types.Field(String, graphql_name="location")

    project_name = sgqlc.types.Field(String, graphql_name="projectName")

    dataset = sgqlc.types.Field(String, graphql_name="dataset")

    description = sgqlc.types.Field(String, graphql_name="description")
    """(Deprecated) Use `description` from `CatalogObjectMetadataModel`"""

    table_type = sgqlc.types.Field(String, graphql_name="tableType")

    is_encrypted = sgqlc.types.Field(Boolean, graphql_name="isEncrypted")

    created_time = sgqlc.types.Field(DateTime, graphql_name="createdTime")

    last_modified = sgqlc.types.Field(DateTime, graphql_name="lastModified")

    view_query = sgqlc.types.Field(String, graphql_name="viewQuery")

    view_is_materialized = sgqlc.types.Field(Boolean, graphql_name="viewIsMaterialized")

    labels = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels"
    )

    path = sgqlc.types.Field(String, graphql_name="path")

    priority = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="priority")

    tracked = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="tracked")

    dynamic_table = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="dynamicTable")

    is_deleted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeleted")

    deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt")

    last_observed = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="lastObserved")

    is_excluded = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isExcluded")

    is_monitored = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isMonitored")
    """Is table monitored? Source of truth for table-based pricing"""

    data_provider = sgqlc.types.Field(String, graphql_name="dataProvider")

    mcon = sgqlc.types.Field(String, graphql_name="mcon")

    importance_score = sgqlc.types.Field(Float, graphql_name="importanceScore")

    is_important = sgqlc.types.Field(Boolean, graphql_name="isImportant")

    last_activity = sgqlc.types.Field(DateTime, graphql_name="lastActivity")

    last_read = sgqlc.types.Field(DateTime, graphql_name="lastRead")

    last_write = sgqlc.types.Field(DateTime, graphql_name="lastWrite")

    last_volume_change = sgqlc.types.Field(DateTime, graphql_name="lastVolumeChange")

    importance_score_is_custom = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="importanceScoreIsCustom"
    )

    is_important_is_custom = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="isImportantIsCustom"
    )

    freshness_anomaly = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="freshnessAnomaly"
    )
    """DEPRECATED"""

    size_anomaly = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="sizeAnomaly")
    """DEPRECATED"""

    freshness_size_anomaly = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="freshnessSizeAnomaly"
    )
    """DEPRECATED"""

    metric_anomaly = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="metricAnomaly")
    """DEPRECATED"""

    status = sgqlc.types.Field(WarehouseTableModelStatus, graphql_name="status")
    """DEPRECATED"""

    tags = sgqlc.types.Field(sgqlc.types.list_of(ObjectProperty), graphql_name="tags")
    """Tags associated with the table"""

    categories_with_monitors = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentCategory), graphql_name="categoriesWithMonitors"
    )
    """Categories that have at least one monitor set up"""

    categories_with_monitor_counts = sgqlc.types.Field(
        sgqlc.types.list_of(IncidentCategoryCount), graphql_name="categoriesWithMonitorCounts"
    )
    """Categories that have at least one monitor set up"""

    incidents = sgqlc.types.Field(
        sgqlc.types.list_of(WarehouseTableIncident),
        graphql_name="incidents",
        args=sgqlc.types.ArgDict(
            (
                (
                    "limit_per_category",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(Int), graphql_name="limitPerCategory", default=None
                    ),
                ),
                (
                    "start_time",
                    sgqlc.types.Arg(
                        sgqlc.types.non_null(DateTime), graphql_name="startTime", default=None
                    ),
                ),
                ("end_time", sgqlc.types.Arg(DateTime, graphql_name="endTime", default=None)),
                (
                    "include_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="includeFeedback", default=None
                    ),
                ),
                (
                    "exclude_feedback",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="excludeFeedback", default=None
                    ),
                ),
                (
                    "include_normalized",
                    sgqlc.types.Arg(Boolean, graphql_name="includeNormalized", default=None),
                ),
                (
                    "severities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="severities", default=None
                    ),
                ),
                (
                    "priorities",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(String), graphql_name="priorities", default=None
                    ),
                ),
                (
                    "categories",
                    sgqlc.types.Arg(
                        sgqlc.types.list_of(IncidentCategory),
                        graphql_name="categories",
                        default=None,
                    ),
                ),
            )
        ),
    )
    """Incidents associated with the table

    Arguments:

    * `limit_per_category` (`Int!`): Maximum number of incidents per
      category
    * `start_time` (`DateTime!`): Filter incidents newer than this
    * `end_time` (`DateTime`): Filter incidents older than this
    * `include_feedback` (`[String]`): Filter incidents by user
      feedback
    * `exclude_feedback` (`[String]`): Exclude incidents by user
      feedback
    * `include_normalized` (`Boolean`): If false, filter out
      normalized incidents.
    * `severities` (`[String]`): Filter for specific severities
    * `priorities` (`[String]`): Filter for specific priorities
    * `categories` (`[IncidentCategory]`): Include only selected
      incident categories. Or all categories if not specified.
    """

    table_capabilities = sgqlc.types.Field(
        TableCapabilitiesResponse, graphql_name="tableCapabilities"
    )
    """Capabilities for the table"""


class WidgetDataSourceJobExecutions(sgqlc.types.Type, WidgetDataSourceInterface):
    __schema__ = schema
    __field_names__ = ("monitor_id",)
    monitor_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="monitorId")


class WidgetDataSourceMetrics(sgqlc.types.Type, WidgetDataSourceInterface):
    __schema__ = schema
    __field_names__ = ("time_series_id",)
    time_series_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="timeSeriesId")


class WidgetDataSourceMonitor(sgqlc.types.Type, WidgetDataSourceInterface):
    __schema__ = schema
    __field_names__ = ("monitor_id",)
    monitor_id = sgqlc.types.Field(sgqlc.types.non_null(UUID), graphql_name="monitorId")


class WidgetOptionsGraph(sgqlc.types.Type, WidgetOptionsInterface):
    __schema__ = schema
    __field_names__ = ("show_thresholds",)
    show_thresholds = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="showThresholds"
    )


class WidgetOptionsScalar(sgqlc.types.Type, WidgetOptionsInterface):
    __schema__ = schema
    __field_names__ = ("field",)
    field = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="field")


class WidgetOptionsTable(sgqlc.types.Type, WidgetOptionsInterface):
    __schema__ = schema
    __field_names__ = ("fields",)
    fields = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="fields",
    )


class WidgetOptionsText(sgqlc.types.Type, WidgetOptionsInterface):
    __schema__ = schema
    __field_names__ = ("content",)
    content = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="content")


########################################################################
# Unions
########################################################################
class AlertScopedRcaData(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (GithubPullRequestInsight,)


class ETLJobUnionType(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (AirflowDag, DatabricksJob, AdfJob, DbtJob)


class ETLTaskUnionType(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (AirflowTask, DatabricksTask, AdfTask)


class ExtendedRca(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (
        JobRca,
        FailedDataRca,
        FutileDataRca,
        ChangeDataRca,
        UpstreamDataRca,
        DbtRca,
        QdrDataRca,
        AirflowRca,
    )


class FreshnessAlertConditionOutput(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (FreshnessAutomatedAlertConditionOutput, FreshnessExplicitAlertConditionOutput)


class GenericAlert(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (Alert, MergedAlert)


class IncidentScopedRcaData(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (GithubPullRequestInsight,)


class LineageJobAttributes(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (
        LineageBaseJobAttributes,
        LineageAirflowJobAttributes,
        LineageDatabricksJobAttributes,
        LineageKafkaConnectorJobAttributes,
        LineageDbtJobAttributes,
        LineageInformaticaJobAttributes,
        LineageAzureDataFactoryJobAttributes,
        LineageFivetranJobAttributes,
    )


class RcaData(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (
        FieldDistRcaResult,
        DataProfileResult,
        MetricCorrelationResult,
        SQLQueryResult,
        FHNumericRcaResult,
        NumericCorrelationRcaResult,
    )


class TimeLineEvent(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (
        EventDataIncidentStatusUpdateTimeline,
        EventDataIncidentSplitTimeline,
        EventDataIncidentSeverityUpdateTimeline,
        EventDataIncidentReactionUpdateTimeline,
        EventDataIncidentOwnerUpdateTimeline,
        EventDataIncidentCommentTimeline,
    )


class UCSAlertConditionOutput(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (UCSAutomatedAlertConditionOutput, UCSExplicitAlertConditionOutput)


class UserDefinedMonitor(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (MetricMonitoring, CustomRule)


class VectorIndexMetadata(sgqlc.types.Union):
    """Union of possible vendor-specific schemas"""

    __schema__ = schema
    __types__ = (PineconeVectorIndexMetadata, UnknownVectorIndexMetadata)


class VolumeChangeAlertConditionOutput(sgqlc.types.Union):
    __schema__ = schema
    __types__ = (
        VolumeChangeAutomatedAlertConditionOutput,
        VolumeChangeExplicitAlertConditionOutput,
    )


########################################################################
# Schema Entry Points
########################################################################
schema.query_type = Query
schema.mutation_type = Mutation
schema.subscription_type = None
