import sgqlc.types
import sgqlc.types.datetime

from newrelic_sb_sdk.graphql import nerdgraph

from newrelic_sb_sdk.graphql.enums import (
    AgentApplicationBrowserLoader,
    AgentApplicationSegmentsListType,
    AgentApplicationSettingsBrowserLoaderInput,
    AgentApplicationSettingsMobileSessionReplayModeInput,
    AgentApplicationSettingsNetworkFilterMode,
    AgentApplicationSettingsRecordSqlEnum,
    AgentApplicationSettingsSessionTraceModeInput,
    AgentApplicationSettingsThresholdTypeEnum,
    AgentApplicationSettingsTracer,
    AiDecisionsIncidentSelect,
    AiDecisionsIssuePriority,
    AiDecisionsRuleSource,
    AiDecisionsRuleType,
    AiDecisionsVertexClass,
    AiIssuesIncidentState,
    AiIssuesIssueMutingState,
    AiIssuesIssueState,
    AiNotificationsAuthType,
    AiNotificationsChannelFields,
    AiNotificationsChannelStatus,
    AiNotificationsChannelType,
    AiNotificationsDestinationFields,
    AiNotificationsDestinationType,
    AiNotificationsEmailVerificationStatus,
    AiNotificationsEntityScopeTypeInput,
    AiNotificationsProduct,
    AiNotificationsSortOrder,
    AiNotificationsSuggestionFilterType,
    AiNotificationsUnverifiedEmailsFields,
    AiNotificationsVariableFields,
    AiNotificationsVariableType,
    AiTopologyCollectorVertexClass,
    AiWorkflowsDestinationType,
    AiWorkflowsFilterType,
    AiWorkflowsMutingRulesHandling,
    AiWorkflowsNotificationTrigger,
    AiWorkflowsOperator,
    AlertsActionOnMutingRuleWindowEnded,
    AlertsAsNrqlSourceProduct,
    AlertsCompoundConditionSortDirection,
    AlertsCompoundConditionSortKey,
    AlertsDayOfWeek,
    AlertsFillOption,
    AlertsIncidentPreference,
    AlertsMutingRuleConditionGroupOperator,
    AlertsMutingRuleConditionOperator,
    AlertsMutingRuleScheduleRepeat,
    AlertsNrqlBaselineDirection,
    AlertsNrqlConditionPriority,
    AlertsNrqlConditionTermsOperator,
    AlertsNrqlConditionThresholdOccurrences,
    AlertsNrqlDynamicConditionTermsOperator,
    AlertsNrqlSignalSeasonality,
    AlertsNrqlStaticConditionValueFunction,
    AlertsOpsGenieDataCenterRegion,
    AlertsSignalAggregationMethod,
    AlertsViolationTimeLimit,
    AlertsWebhookCustomPayloadType,
    ApiAccessIngestKeyType,
    ApiAccessKeyType,
    AuthorizationManagementGranteeTypeEnum,
    AuthorizationManagementIamParentScopeTypeEnum,
    ChangeTrackingDeploymentType,
    ChangeTrackingValidationFlag,
    CloudCostIntelligenceIntegrationFilterOperator,
    CloudMetricCollectionMode,
    DashboardAlertSeverity,
    DashboardLiveUrlAuthType,
    DashboardLiveUrlType,
    DashboardPermissions,
    DashboardVariableReplacementStrategy,
    DashboardVariableType,
    DataAccessPolicyAssignedStatus,
    DataAccessPolicySortKey,
    DataAccessPolicySortOrder,
    DataSourceGapsGapTypeIdentifier,
    EdgeComplianceTypeCode,
    EdgeDataSourceGroupUpdateType,
    EdgeProviderRegion,
    EdgeSpanAttributeKeyOperator,
    EdgeSpanAttributeValueOperator,
    EdgeTraceFilterAction,
    EntityAlertSeverity,
    EntityInfrastructureIntegrationType,
    EntityManagementAiToolParameterType,
    EntityManagementAiToolType,
    EntityManagementCategoryScopeType,
    EntityManagementEncodingName,
    EntityManagementEntityScope,
    EntityManagementExternalOwnerType,
    EntityManagementHostingPlatform,
    EntityManagementIncidentTimelineSource,
    EntityManagementIssueType,
    EntityManagementLicenseName,
    EntityManagementMcpAuthType,
    EntityManagementMcpTransport,
    EntityManagementSyncGroupRuleConditionType,
    EntityManagementTeamExternalIntegrationType,
    EntityManagementTextSplitterType,
    EntityRelationshipEdgeDirection,
    EntityRelationshipEdgeType,
    EntitySearchQueryBuilderDomain,
    EntitySearchQueryBuilderType,
    EntitySearchSortCriteria,
    EntityType,
    ErrorsInboxDirection,
    ErrorsInboxErrorGroupSortOrderField,
    ErrorsInboxErrorGroupState,
    ErrorsInboxEventSource,
    ErrorsInboxResourceType,
    FleetControlEntityScope,
    FleetControlManagedEntityType,
    FleetControlOperatingSystemType,
    InstallationInstallStateType,
    InstallationRecipeStatusType,
    LogConfigurationsDataPartitionRuleMatchingOperator,
    LogConfigurationsDataPartitionRuleRetentionPolicyType,
    LogConfigurationsObfuscationMethod,
    LogConfigurationsParsingRuleSource,
    MachineLearningEncodingName,
    MachineLearningFilterByKeys,
    MachineLearningOperator,
    MachineLearningTextSplitterType,
    MetricNormalizationCustomerRuleAction,
    MultiTenantAuthorizationGranteeTypeEnum,
    MultiTenantAuthorizationGrantScopeEnum,
    MultiTenantAuthorizationGrantSortEnum,
    MultiTenantAuthorizationRoleScopeEnum,
    MultiTenantAuthorizationRoleSortEnum,
    MultiTenantAuthorizationRoleTypeEnum,
    MultiTenantAuthorizationSortDirectionEnum,
    MultiTenantIdentityCapability,
    MultiTenantIdentitySortDirection,
    MultiTenantIdentitySortKeyEnum,
    MultiTenantIdentityUserSortKey,
    NerdpackSubscriptionModel,
    NerdpackVersionFilterFallback,
    NerdStorageScope,
    NerdStorageVaultActorScope,
    Nr1CatalogSearchComponentType,
    Nr1CatalogSearchResultType,
    NrqlDropRulesAction,
    OrganizationAccountShareSortDirectionEnum,
    OrganizationAccountShareSortKeyEnum,
    OrganizationAccountSortDirectionEnum,
    OrganizationAccountSortKeyEnum,
    OrganizationAccountStatus,
    OrganizationMembersOrganizationMemberType,
    OrganizationOrganizationCreateJobStatusEnum,
    OrganizationProvisioningUnit,
    OrganizationRegionCodeEnum,
    OrganizationSharingMode,
    OrganizationSortDirectionEnum,
    OrganizationSortKeyEnum,
    SecretsManagementScopeType,
    SecretsManagementSortDirection,
    SecretsManagementSortKey,
    ServiceLevelEventsQuerySelectFunction,
    ServiceLevelObjectiveRollingTimeWindowUnit,
    SessionsClientType,
    SortBy,
    StreamingExportPayloadCompression,
    SyntheticsBrowser,
    SyntheticsDevice,
    SyntheticsDeviceOrientation,
    SyntheticsDeviceType,
    SyntheticsMonitorDowntimeDayOfMonthOrdinal,
    SyntheticsMonitorDowntimeWeekDays,
    SyntheticsMonitorPeriod,
    SyntheticsMonitorStatus,
    SyntheticsStepType,
    SystemIdentityIdentitySortFieldKey,
    SystemIdentityIdentityType,
    SystemIdentitySortOrder,
    UserManagementGroupSortKey,
    UserManagementRequestedTierName,
    UserManagementSortDirection,
    UserManagementTypeEnum,
    WhatsNewContentType,
    WorkflowAutomationScopeType,
    WorkflowAutomationWorkflowLogLevel,
    WorkflowAutomationWorkflowRunScopeType,
    WorkloadGroupRemainingEntitiesRuleBy,
    WorkloadRollupStrategy,
    WorkloadRuleThresholdType,
    WorkloadStatusValueInput,
)

from newrelic_sb_sdk.graphql.scalars import (
    ID,
    AgentApplicationSettingsCustomJsConfiguration,
    AgentApplicationSettingsErrorCollectorHttpStatus,
    Boolean,
    ChangeTrackingRawCustomAttributesMap,
    DashboardWidgetRawConfiguration,
    Date,
    DateTime,
    EntityGuid,
    EpochMilliseconds,
    EpochSeconds,
    ErrorsInboxRawEvent,
    Float,
    InstallationRawMetadata,
    Int,
    LogConfigurationsLogDataPartitionName,
    Milliseconds,
    NaiveDateTime,
    NerdpackTagName,
    Nrql,
    Seconds,
    SecureValue,
    SemVer,
    String,
    WorkflowAutomationRawWorkflowInputValue,
)

__docformat__ = "markdown"

class AccountManagementCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("name", "organization_id", "region_code")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    organization_id = sgqlc.types.Field(ID, graphql_name="organizationId")

    region_code = sgqlc.types.Field(String, graphql_name="regionCode")

class AccountManagementUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("id", "name")
    id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="id")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AgentApplicationBrowserSettingsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("cookies_enabled", "distributed_tracing_enabled", "loader_type")
    cookies_enabled = sgqlc.types.Field(Boolean, graphql_name="cookiesEnabled")

    distributed_tracing_enabled = sgqlc.types.Field(
        Boolean, graphql_name="distributedTracingEnabled"
    )

    loader_type = sgqlc.types.Field(
        AgentApplicationBrowserLoader, graphql_name="loaderType"
    )

class AgentApplicationSegmentsBrowserSegmentAllowListInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("segments",)
    segments = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="segments"
    )

class AgentApplicationSegmentsSegmentAllowListFilters(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("list_type",)
    list_type = sgqlc.types.Field(
        AgentApplicationSegmentsListType, graphql_name="listType"
    )

class AgentApplicationSettingsApmConfigInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("apdex_target", "use_server_side_config")
    apdex_target = sgqlc.types.Field(Float, graphql_name="apdexTarget")

    use_server_side_config = sgqlc.types.Field(
        Boolean, graphql_name="useServerSideConfig"
    )

class AgentApplicationSettingsApplicationExitInfoInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

class AgentApplicationSettingsBrowserAjaxInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("deny_list",)
    deny_list = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="denyList"
    )

class AgentApplicationSettingsBrowserConfigInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("apdex_target",)
    apdex_target = sgqlc.types.Field(Float, graphql_name="apdexTarget")

class AgentApplicationSettingsBrowserConsentModeInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

class AgentApplicationSettingsBrowserDistributedTracingInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "allowed_origins",
        "cors_enabled",
        "cors_use_newrelic_header",
        "cors_use_tracecontext_headers",
        "enabled",
        "exclude_newrelic_header",
    )
    allowed_origins = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="allowedOrigins"
    )

    cors_enabled = sgqlc.types.Field(Boolean, graphql_name="corsEnabled")

    cors_use_newrelic_header = sgqlc.types.Field(
        Boolean, graphql_name="corsUseNewrelicHeader"
    )

    cors_use_tracecontext_headers = sgqlc.types.Field(
        Boolean, graphql_name="corsUseTracecontextHeaders"
    )

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    exclude_newrelic_header = sgqlc.types.Field(
        Boolean, graphql_name="excludeNewrelicHeader"
    )

class AgentApplicationSettingsBrowserMonitoringInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "ajax",
        "distributed_tracing",
        "loader",
        "pinned_version",
        "privacy",
    )
    ajax = sgqlc.types.Field(
        AgentApplicationSettingsBrowserAjaxInput, graphql_name="ajax"
    )

    distributed_tracing = sgqlc.types.Field(
        AgentApplicationSettingsBrowserDistributedTracingInput,
        graphql_name="distributedTracing",
    )

    loader = sgqlc.types.Field(
        AgentApplicationSettingsBrowserLoaderInput, graphql_name="loader"
    )

    pinned_version = sgqlc.types.Field(String, graphql_name="pinnedVersion")

    privacy = sgqlc.types.Field(
        "AgentApplicationSettingsBrowserPrivacyInput", graphql_name="privacy"
    )

class AgentApplicationSettingsBrowserPerformanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("capture_detail", "capture_marks", "capture_measures")
    capture_detail = sgqlc.types.Field(Boolean, graphql_name="captureDetail")

    capture_marks = sgqlc.types.Field(Boolean, graphql_name="captureMarks")

    capture_measures = sgqlc.types.Field(Boolean, graphql_name="captureMeasures")

class AgentApplicationSettingsBrowserPrivacyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("cookies_enabled",)
    cookies_enabled = sgqlc.types.Field(Boolean, graphql_name="cookiesEnabled")

class AgentApplicationSettingsErrorCollectorInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "enabled",
        "expected_error_classes",
        "expected_error_codes",
        "ignored_error_classes",
        "ignored_error_codes",
    )
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    expected_error_classes = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)),
        graphql_name="expectedErrorClasses",
    )

    expected_error_codes = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AgentApplicationSettingsErrorCollectorHttpStatus)
        ),
        graphql_name="expectedErrorCodes",
    )

    ignored_error_classes = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)),
        graphql_name="ignoredErrorClasses",
    )

    ignored_error_codes = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AgentApplicationSettingsErrorCollectorHttpStatus)
        ),
        graphql_name="ignoredErrorCodes",
    )

class AgentApplicationSettingsIgnoredStatusCodeRuleInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("hosts", "status_codes")
    hosts = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="hosts",
    )

    status_codes = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="statusCodes",
    )

class AgentApplicationSettingsJfrInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

class AgentApplicationSettingsMaskInputOptionsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "color",
        "date",
        "datetime_local",
        "email",
        "month",
        "number",
        "range",
        "search",
        "select",
        "tel",
        "text",
        "text_area",
        "time",
        "url",
        "week",
    )
    color = sgqlc.types.Field(Boolean, graphql_name="color")

    date = sgqlc.types.Field(Boolean, graphql_name="date")

    datetime_local = sgqlc.types.Field(Boolean, graphql_name="datetimeLocal")

    email = sgqlc.types.Field(Boolean, graphql_name="email")

    month = sgqlc.types.Field(Boolean, graphql_name="month")

    number = sgqlc.types.Field(Boolean, graphql_name="number")

    range = sgqlc.types.Field(Boolean, graphql_name="range")

    search = sgqlc.types.Field(Boolean, graphql_name="search")

    select = sgqlc.types.Field(Boolean, graphql_name="select")

    tel = sgqlc.types.Field(Boolean, graphql_name="tel")

    text = sgqlc.types.Field(Boolean, graphql_name="text")

    text_area = sgqlc.types.Field(Boolean, graphql_name="textArea")

    time = sgqlc.types.Field(Boolean, graphql_name="time")

    url = sgqlc.types.Field(Boolean, graphql_name="url")

    week = sgqlc.types.Field(Boolean, graphql_name="week")

class AgentApplicationSettingsMobileSessionReplayInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "custom_masking_rules",
        "enabled",
        "error_sampling_rate",
        "mask_all_images",
        "mask_all_user_touches",
        "mask_application_text",
        "mask_user_input_text",
        "mode",
        "sampling_rate",
    )
    custom_masking_rules = sgqlc.types.Field(
        AgentApplicationSettingsCustomJsConfiguration, graphql_name="customMaskingRules"
    )

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    error_sampling_rate = sgqlc.types.Field(Float, graphql_name="errorSamplingRate")

    mask_all_images = sgqlc.types.Field(Boolean, graphql_name="maskAllImages")

    mask_all_user_touches = sgqlc.types.Field(
        Boolean, graphql_name="maskAllUserTouches"
    )

    mask_application_text = sgqlc.types.Field(
        Boolean, graphql_name="maskApplicationText"
    )

    mask_user_input_text = sgqlc.types.Field(Boolean, graphql_name="maskUserInputText")

    mode = sgqlc.types.Field(
        AgentApplicationSettingsMobileSessionReplayModeInput, graphql_name="mode"
    )

    sampling_rate = sgqlc.types.Field(Float, graphql_name="samplingRate")

class AgentApplicationSettingsMobileSettingsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "application_exit_info",
        "mobile_session_replay",
        "network_settings",
        "use_crash_reports",
    )
    application_exit_info = sgqlc.types.Field(
        AgentApplicationSettingsApplicationExitInfoInput,
        graphql_name="applicationExitInfo",
    )

    mobile_session_replay = sgqlc.types.Field(
        AgentApplicationSettingsMobileSessionReplayInput,
        graphql_name="mobileSessionReplay",
    )

    network_settings = sgqlc.types.Field(
        "AgentApplicationSettingsNetworkSettingsInput", graphql_name="networkSettings"
    )

    use_crash_reports = sgqlc.types.Field(Boolean, graphql_name="useCrashReports")

class AgentApplicationSettingsNetworkAliasesInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("alias", "hosts")
    alias = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="alias")

    hosts = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="hosts",
    )

class AgentApplicationSettingsNetworkSettingsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "aliases",
        "filter_mode",
        "hide_list",
        "ignored_status_code_rules",
        "show_list",
    )
    aliases = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AgentApplicationSettingsNetworkAliasesInput)
        ),
        graphql_name="aliases",
    )

    filter_mode = sgqlc.types.Field(
        AgentApplicationSettingsNetworkFilterMode, graphql_name="filterMode"
    )

    hide_list = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="hideList"
    )

    ignored_status_code_rules = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AgentApplicationSettingsIgnoredStatusCodeRuleInput)
        ),
        graphql_name="ignoredStatusCodeRules",
    )

    show_list = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="showList"
    )

class AgentApplicationSettingsSessionReplayInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "auto_start",
        "block_selector",
        "collect_fonts",
        "enabled",
        "error_sampling_rate",
        "fix_stylesheets",
        "inline_images",
        "inline_stylesheet",
        "mask_all_inputs",
        "mask_input_options",
        "mask_text_selector",
        "preload",
        "sampling_rate",
    )
    auto_start = sgqlc.types.Field(Boolean, graphql_name="autoStart")

    block_selector = sgqlc.types.Field(String, graphql_name="blockSelector")

    collect_fonts = sgqlc.types.Field(Boolean, graphql_name="collectFonts")

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    error_sampling_rate = sgqlc.types.Field(Float, graphql_name="errorSamplingRate")

    fix_stylesheets = sgqlc.types.Field(Boolean, graphql_name="fixStylesheets")

    inline_images = sgqlc.types.Field(Boolean, graphql_name="inlineImages")

    inline_stylesheet = sgqlc.types.Field(Boolean, graphql_name="inlineStylesheet")

    mask_all_inputs = sgqlc.types.Field(Boolean, graphql_name="maskAllInputs")

    mask_input_options = sgqlc.types.Field(
        AgentApplicationSettingsMaskInputOptionsInput, graphql_name="maskInputOptions"
    )

    mask_text_selector = sgqlc.types.Field(String, graphql_name="maskTextSelector")

    preload = sgqlc.types.Field(Boolean, graphql_name="preload")

    sampling_rate = sgqlc.types.Field(Float, graphql_name="samplingRate")

class AgentApplicationSettingsSessionTraceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled", "error_sampling_rate", "mode", "sampling_rate")
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    error_sampling_rate = sgqlc.types.Field(Float, graphql_name="errorSamplingRate")

    mode = sgqlc.types.Field(
        AgentApplicationSettingsSessionTraceModeInput, graphql_name="mode"
    )

    sampling_rate = sgqlc.types.Field(Float, graphql_name="samplingRate")

class AgentApplicationSettingsSlowSqlInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

class AgentApplicationSettingsThreadProfilerInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

class AgentApplicationSettingsTracerTypeInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("value",)
    value = sgqlc.types.Field(AgentApplicationSettingsTracer, graphql_name="value")

class AgentApplicationSettingsTransactionTracerInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "capture_memcache_keys",
        "enabled",
        "explain_enabled",
        "explain_threshold_type",
        "explain_threshold_value",
        "log_sql",
        "record_sql",
        "stack_trace_threshold",
        "transaction_threshold_type",
        "transaction_threshold_value",
    )
    capture_memcache_keys = sgqlc.types.Field(
        Boolean, graphql_name="captureMemcacheKeys"
    )

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    explain_enabled = sgqlc.types.Field(Boolean, graphql_name="explainEnabled")

    explain_threshold_type = sgqlc.types.Field(
        AgentApplicationSettingsThresholdTypeEnum, graphql_name="explainThresholdType"
    )

    explain_threshold_value = sgqlc.types.Field(
        Seconds, graphql_name="explainThresholdValue"
    )

    log_sql = sgqlc.types.Field(Boolean, graphql_name="logSql")

    record_sql = sgqlc.types.Field(
        AgentApplicationSettingsRecordSqlEnum, graphql_name="recordSql"
    )

    stack_trace_threshold = sgqlc.types.Field(
        Seconds, graphql_name="stackTraceThreshold"
    )

    transaction_threshold_type = sgqlc.types.Field(
        AgentApplicationSettingsThresholdTypeEnum,
        graphql_name="transactionThresholdType",
    )

    transaction_threshold_value = sgqlc.types.Field(
        Seconds, graphql_name="transactionThresholdValue"
    )

class AgentApplicationSettingsUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "alias",
        "apm_config",
        "browser_config",
        "browser_consent_mode",
        "browser_monitoring",
        "browser_performance",
        "capture_memcache_keys",
        "error_collector",
        "jfr",
        "mobile_settings",
        "name",
        "session_replay",
        "session_trace",
        "slow_sql",
        "thread_profiler",
        "tracer_type",
        "transaction_tracer",
    )
    alias = sgqlc.types.Field(String, graphql_name="alias")

    apm_config = sgqlc.types.Field(
        AgentApplicationSettingsApmConfigInput, graphql_name="apmConfig"
    )

    browser_config = sgqlc.types.Field(
        AgentApplicationSettingsBrowserConfigInput, graphql_name="browserConfig"
    )

    browser_consent_mode = sgqlc.types.Field(
        AgentApplicationSettingsBrowserConsentModeInput,
        graphql_name="browserConsentMode",
    )

    browser_monitoring = sgqlc.types.Field(
        AgentApplicationSettingsBrowserMonitoringInput, graphql_name="browserMonitoring"
    )

    browser_performance = sgqlc.types.Field(
        AgentApplicationSettingsBrowserPerformanceInput,
        graphql_name="browserPerformance",
    )

    capture_memcache_keys = sgqlc.types.Field(
        Boolean, graphql_name="captureMemcacheKeys"
    )

    error_collector = sgqlc.types.Field(
        AgentApplicationSettingsErrorCollectorInput, graphql_name="errorCollector"
    )

    jfr = sgqlc.types.Field(AgentApplicationSettingsJfrInput, graphql_name="jfr")

    mobile_settings = sgqlc.types.Field(
        AgentApplicationSettingsMobileSettingsInput, graphql_name="mobileSettings"
    )

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

    session_replay = sgqlc.types.Field(
        AgentApplicationSettingsSessionReplayInput, graphql_name="sessionReplay"
    )

    session_trace = sgqlc.types.Field(
        AgentApplicationSettingsSessionTraceInput, graphql_name="sessionTrace"
    )

    slow_sql = sgqlc.types.Field(
        AgentApplicationSettingsSlowSqlInput, graphql_name="slowSql"
    )

    thread_profiler = sgqlc.types.Field(
        AgentApplicationSettingsThreadProfilerInput, graphql_name="threadProfiler"
    )

    tracer_type = sgqlc.types.Field(
        AgentApplicationSettingsTracerTypeInput, graphql_name="tracerType"
    )

    transaction_tracer = sgqlc.types.Field(
        AgentApplicationSettingsTransactionTracerInput, graphql_name="transactionTracer"
    )

class AgentEnvironmentFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("contains", "does_not_contain", "equals", "starts_with")
    contains = sgqlc.types.Field(String, graphql_name="contains")

    does_not_contain = sgqlc.types.Field(String, graphql_name="doesNotContain")

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

    starts_with = sgqlc.types.Field(String, graphql_name="startsWith")

class AiDecisionsAllInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("children",)
    children = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AiDecisionsRuleExpressionInput"))
        ),
        graphql_name="children",
    )

class AiDecisionsAndInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsRuleExpressionInput"), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsRuleExpressionInput"), graphql_name="right"
    )

class AiDecisionsAttributeExistsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident",)
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

class AiDecisionsCategoricalClusteringInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("threshold",)
    threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="threshold")

class AiDecisionsFixedContainsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("container", "value")
    container = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="container"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedCosineDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "max_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedEndsWithInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedFuzzyScoreInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="minDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedFuzzyWuzzyAdaptiveRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_similarity", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedFuzzyWuzzyPartialRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_similarity", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedFuzzyWuzzyRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_similarity", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedFuzzyWuzzyTokenSetRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_similarity", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedGreaterThanInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("compared", "incident")
    compared = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="compared")

    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

class AiDecisionsFixedGreaterThanOrEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("compared", "incident")
    compared = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="compared")

    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

class AiDecisionsFixedHammingDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "max_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedJaccardDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "max_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedJaroWinklerInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedLessThanInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("compared", "incident")
    compared = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="compared")

    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

class AiDecisionsFixedLessThanOrEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("compared", "incident")
    compared = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="compared")

    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

class AiDecisionsFixedLevenshteinInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "max_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedLongestCommonSubsequenceDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "max_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedNumericalEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("compared", "incident")
    compared = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="compared")

    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

class AiDecisionsFixedRegularExpressionInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedSoundExInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "min_distance", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    min_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="minDistance"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsFixedStartsWithInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident", "value")
    incident = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsIncidentObjectInput"), graphql_name="incident"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsIncidentObjectInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("attribute", "select")
    attribute = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="attribute"
    )

    select = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentSelect), graphql_name="select"
    )

class AiDecisionsNotInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("child",)
    child = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsRuleExpressionInput"), graphql_name="child"
    )

class AiDecisionsOneInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("children",)
    children = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AiDecisionsRuleExpressionInput"))
        ),
        graphql_name="children",
    )

class AiDecisionsOrInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsRuleExpressionInput"), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsRuleExpressionInput"), graphql_name="right"
    )

class AiDecisionsOverrideConfigurationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("description", "priority", "title")
    description = sgqlc.types.Field(String, graphql_name="description")

    priority = sgqlc.types.Field(AiDecisionsIssuePriority, graphql_name="priority")

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

class AiDecisionsRelativeCommonPrefixInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("value",)
    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsRelativeContainsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("contained", "container")
    contained = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="contained"
    )

    container = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="container"
    )

class AiDecisionsRelativeCosineDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "max_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeEndsWithInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("contained", "container")
    contained = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="contained"
    )

    container = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="container"
    )

class AiDecisionsRelativeEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeFuzzyScoreInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="minDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeFuzzyWuzzyAdaptiveRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_similarity", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeFuzzyWuzzyPartialRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_similarity", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeFuzzyWuzzyRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_similarity", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeFuzzyWuzzyTokenSetRatioInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_similarity", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_similarity = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minSimilarity"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeGreaterThanInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeGreaterThanOrEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeHammingDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "max_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeJaccardDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "max_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeJaroWinklerInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="minDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeLessThanInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeLessThanOrEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeLevenshteinInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "max_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="maxDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeLongestCommonSubsequenceDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "max_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeNumericalEqualInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeRegularExpressionInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "right", "value")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiDecisionsRelativeSoundExInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("left", "min_distance", "right")
    left = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="left"
    )

    min_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="minDistance"
    )

    right = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="right"
    )

class AiDecisionsRelativeStartsWithInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("contained", "container")
    contained = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="contained"
    )

    container = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsIncidentObjectInput), graphql_name="container"
    )

class AiDecisionsRelativeTopologicallyDependentInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "from_",
        "graph_id",
        "max_hops",
        "required_attributes",
        "required_classes",
        "to",
    )
    from_ = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))),
        graphql_name="from",
    )

    graph_id = sgqlc.types.Field(ID, graphql_name="graphId")

    max_hops = sgqlc.types.Field(Int, graphql_name="maxHops")

    required_attributes = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="requiredAttributes",
    )

    required_classes = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(AiDecisionsVertexClass))
        ),
        graphql_name="requiredClasses",
    )

    to = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))),
        graphql_name="to",
    )

class AiDecisionsRuleBlueprint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "correlation_window_length",
        "creator",
        "description",
        "min_correlation_threshold",
        "name",
        "override_configuration",
        "rule_expression",
        "rule_type",
        "source",
    )
    correlation_window_length = sgqlc.types.Field(
        Milliseconds, graphql_name="correlationWindowLength"
    )

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

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

    min_correlation_threshold = sgqlc.types.Field(
        Int, graphql_name="minCorrelationThreshold"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    override_configuration = sgqlc.types.Field(
        AiDecisionsOverrideConfigurationInput, graphql_name="overrideConfiguration"
    )

    rule_expression = sgqlc.types.Field(
        sgqlc.types.non_null("AiDecisionsRuleExpressionInput"),
        graphql_name="ruleExpression",
    )

    rule_type = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsRuleType), graphql_name="ruleType"
    )

    source = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsRuleSource), graphql_name="source"
    )

class AiDecisionsRuleExpressionInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "all",
        "and_",
        "attribute_exists",
        "categorical_clustering",
        "fixed_contains",
        "fixed_cosine_distance",
        "fixed_ends_with",
        "fixed_equal",
        "fixed_fuzzy_score",
        "fixed_fuzzy_wuzzy_adaptive_ratio",
        "fixed_fuzzy_wuzzy_partial_ratio",
        "fixed_fuzzy_wuzzy_ratio",
        "fixed_fuzzy_wuzzy_token_set_ratio",
        "fixed_greater_than",
        "fixed_greater_than_or_equal",
        "fixed_hamming_distance",
        "fixed_jaccard_distance",
        "fixed_jaro_winkler",
        "fixed_less_than",
        "fixed_less_than_or_equal",
        "fixed_levenshtein",
        "fixed_longest_common_subsequence_distance",
        "fixed_numerical_equal",
        "fixed_regular_expression",
        "fixed_sound_ex",
        "fixed_starts_with",
        "not_",
        "one",
        "or_",
        "relative_common_prefix",
        "relative_contains",
        "relative_cosine_distance",
        "relative_ends_with",
        "relative_equal",
        "relative_fuzzy_score",
        "relative_fuzzy_wuzzy_adaptive_ratio",
        "relative_fuzzy_wuzzy_partial_ratio",
        "relative_fuzzy_wuzzy_ratio",
        "relative_fuzzy_wuzzy_token_set_ratio",
        "relative_greater_than",
        "relative_greater_than_or_equal",
        "relative_hamming_distance",
        "relative_jaccard_distance",
        "relative_jaro_winkler",
        "relative_less_than",
        "relative_less_than_or_equal",
        "relative_levenshtein",
        "relative_longest_common_subsequence_distance",
        "relative_numerical_equal",
        "relative_regular_expression",
        "relative_sound_ex",
        "relative_starts_with",
        "relative_topologically_dependent",
        "whole_cosine_distance",
        "whole_jaccard_similarity",
    )
    all = sgqlc.types.Field(AiDecisionsAllInput, graphql_name="all")

    and_ = sgqlc.types.Field(AiDecisionsAndInput, graphql_name="and")

    attribute_exists = sgqlc.types.Field(
        AiDecisionsAttributeExistsInput, graphql_name="attributeExists"
    )

    categorical_clustering = sgqlc.types.Field(
        AiDecisionsCategoricalClusteringInput, graphql_name="categoricalClustering"
    )

    fixed_contains = sgqlc.types.Field(
        AiDecisionsFixedContainsInput, graphql_name="fixedContains"
    )

    fixed_cosine_distance = sgqlc.types.Field(
        AiDecisionsFixedCosineDistanceInput, graphql_name="fixedCosineDistance"
    )

    fixed_ends_with = sgqlc.types.Field(
        AiDecisionsFixedEndsWithInput, graphql_name="fixedEndsWith"
    )

    fixed_equal = sgqlc.types.Field(
        AiDecisionsFixedEqualInput, graphql_name="fixedEqual"
    )

    fixed_fuzzy_score = sgqlc.types.Field(
        AiDecisionsFixedFuzzyScoreInput, graphql_name="fixedFuzzyScore"
    )

    fixed_fuzzy_wuzzy_adaptive_ratio = sgqlc.types.Field(
        AiDecisionsFixedFuzzyWuzzyAdaptiveRatioInput,
        graphql_name="fixedFuzzyWuzzyAdaptiveRatio",
    )

    fixed_fuzzy_wuzzy_partial_ratio = sgqlc.types.Field(
        AiDecisionsFixedFuzzyWuzzyPartialRatioInput,
        graphql_name="fixedFuzzyWuzzyPartialRatio",
    )

    fixed_fuzzy_wuzzy_ratio = sgqlc.types.Field(
        AiDecisionsFixedFuzzyWuzzyRatioInput, graphql_name="fixedFuzzyWuzzyRatio"
    )

    fixed_fuzzy_wuzzy_token_set_ratio = sgqlc.types.Field(
        AiDecisionsFixedFuzzyWuzzyTokenSetRatioInput,
        graphql_name="fixedFuzzyWuzzyTokenSetRatio",
    )

    fixed_greater_than = sgqlc.types.Field(
        AiDecisionsFixedGreaterThanInput, graphql_name="fixedGreaterThan"
    )

    fixed_greater_than_or_equal = sgqlc.types.Field(
        AiDecisionsFixedGreaterThanOrEqualInput, graphql_name="fixedGreaterThanOrEqual"
    )

    fixed_hamming_distance = sgqlc.types.Field(
        AiDecisionsFixedHammingDistanceInput, graphql_name="fixedHammingDistance"
    )

    fixed_jaccard_distance = sgqlc.types.Field(
        AiDecisionsFixedJaccardDistanceInput, graphql_name="fixedJaccardDistance"
    )

    fixed_jaro_winkler = sgqlc.types.Field(
        AiDecisionsFixedJaroWinklerInput, graphql_name="fixedJaroWinkler"
    )

    fixed_less_than = sgqlc.types.Field(
        AiDecisionsFixedLessThanInput, graphql_name="fixedLessThan"
    )

    fixed_less_than_or_equal = sgqlc.types.Field(
        AiDecisionsFixedLessThanOrEqualInput, graphql_name="fixedLessThanOrEqual"
    )

    fixed_levenshtein = sgqlc.types.Field(
        AiDecisionsFixedLevenshteinInput, graphql_name="fixedLevenshtein"
    )

    fixed_longest_common_subsequence_distance = sgqlc.types.Field(
        AiDecisionsFixedLongestCommonSubsequenceDistanceInput,
        graphql_name="fixedLongestCommonSubsequenceDistance",
    )

    fixed_numerical_equal = sgqlc.types.Field(
        AiDecisionsFixedNumericalEqualInput, graphql_name="fixedNumericalEqual"
    )

    fixed_regular_expression = sgqlc.types.Field(
        AiDecisionsFixedRegularExpressionInput, graphql_name="fixedRegularExpression"
    )

    fixed_sound_ex = sgqlc.types.Field(
        AiDecisionsFixedSoundExInput, graphql_name="fixedSoundEx"
    )

    fixed_starts_with = sgqlc.types.Field(
        AiDecisionsFixedStartsWithInput, graphql_name="fixedStartsWith"
    )

    not_ = sgqlc.types.Field(AiDecisionsNotInput, graphql_name="not")

    one = sgqlc.types.Field(AiDecisionsOneInput, graphql_name="one")

    or_ = sgqlc.types.Field(AiDecisionsOrInput, graphql_name="or")

    relative_common_prefix = sgqlc.types.Field(
        AiDecisionsRelativeCommonPrefixInput, graphql_name="relativeCommonPrefix"
    )

    relative_contains = sgqlc.types.Field(
        AiDecisionsRelativeContainsInput, graphql_name="relativeContains"
    )

    relative_cosine_distance = sgqlc.types.Field(
        AiDecisionsRelativeCosineDistanceInput, graphql_name="relativeCosineDistance"
    )

    relative_ends_with = sgqlc.types.Field(
        AiDecisionsRelativeEndsWithInput, graphql_name="relativeEndsWith"
    )

    relative_equal = sgqlc.types.Field(
        AiDecisionsRelativeEqualInput, graphql_name="relativeEqual"
    )

    relative_fuzzy_score = sgqlc.types.Field(
        AiDecisionsRelativeFuzzyScoreInput, graphql_name="relativeFuzzyScore"
    )

    relative_fuzzy_wuzzy_adaptive_ratio = sgqlc.types.Field(
        AiDecisionsRelativeFuzzyWuzzyAdaptiveRatioInput,
        graphql_name="relativeFuzzyWuzzyAdaptiveRatio",
    )

    relative_fuzzy_wuzzy_partial_ratio = sgqlc.types.Field(
        AiDecisionsRelativeFuzzyWuzzyPartialRatioInput,
        graphql_name="relativeFuzzyWuzzyPartialRatio",
    )

    relative_fuzzy_wuzzy_ratio = sgqlc.types.Field(
        AiDecisionsRelativeFuzzyWuzzyRatioInput, graphql_name="relativeFuzzyWuzzyRatio"
    )

    relative_fuzzy_wuzzy_token_set_ratio = sgqlc.types.Field(
        AiDecisionsRelativeFuzzyWuzzyTokenSetRatioInput,
        graphql_name="relativeFuzzyWuzzyTokenSetRatio",
    )

    relative_greater_than = sgqlc.types.Field(
        AiDecisionsRelativeGreaterThanInput, graphql_name="relativeGreaterThan"
    )

    relative_greater_than_or_equal = sgqlc.types.Field(
        AiDecisionsRelativeGreaterThanOrEqualInput,
        graphql_name="relativeGreaterThanOrEqual",
    )

    relative_hamming_distance = sgqlc.types.Field(
        AiDecisionsRelativeHammingDistanceInput, graphql_name="relativeHammingDistance"
    )

    relative_jaccard_distance = sgqlc.types.Field(
        AiDecisionsRelativeJaccardDistanceInput, graphql_name="relativeJaccardDistance"
    )

    relative_jaro_winkler = sgqlc.types.Field(
        AiDecisionsRelativeJaroWinklerInput, graphql_name="relativeJaroWinkler"
    )

    relative_less_than = sgqlc.types.Field(
        AiDecisionsRelativeLessThanInput, graphql_name="relativeLessThan"
    )

    relative_less_than_or_equal = sgqlc.types.Field(
        AiDecisionsRelativeLessThanOrEqualInput, graphql_name="relativeLessThanOrEqual"
    )

    relative_levenshtein = sgqlc.types.Field(
        AiDecisionsRelativeLevenshteinInput, graphql_name="relativeLevenshtein"
    )

    relative_longest_common_subsequence_distance = sgqlc.types.Field(
        AiDecisionsRelativeLongestCommonSubsequenceDistanceInput,
        graphql_name="relativeLongestCommonSubsequenceDistance",
    )

    relative_numerical_equal = sgqlc.types.Field(
        AiDecisionsRelativeNumericalEqualInput, graphql_name="relativeNumericalEqual"
    )

    relative_regular_expression = sgqlc.types.Field(
        AiDecisionsRelativeRegularExpressionInput,
        graphql_name="relativeRegularExpression",
    )

    relative_sound_ex = sgqlc.types.Field(
        AiDecisionsRelativeSoundExInput, graphql_name="relativeSoundEx"
    )

    relative_starts_with = sgqlc.types.Field(
        AiDecisionsRelativeStartsWithInput, graphql_name="relativeStartsWith"
    )

    relative_topologically_dependent = sgqlc.types.Field(
        AiDecisionsRelativeTopologicallyDependentInput,
        graphql_name="relativeTopologicallyDependent",
    )

    whole_cosine_distance = sgqlc.types.Field(
        "AiDecisionsWholeCosineDistanceInput", graphql_name="wholeCosineDistance"
    )

    whole_jaccard_similarity = sgqlc.types.Field(
        "AiDecisionsWholeJaccardSimilarityInput", graphql_name="wholeJaccardSimilarity"
    )

class AiDecisionsSearchBlueprint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("expression", "limit", "retention_window_length")
    expression = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsRuleExpressionInput), graphql_name="expression"
    )

    limit = sgqlc.types.Field(Int, graphql_name="limit")

    retention_window_length = sgqlc.types.Field(
        Milliseconds, graphql_name="retentionWindowLength"
    )

class AiDecisionsSimulationBlueprint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "correlation_window_length",
        "expression",
        "min_correlation_threshold",
        "retention_window_length",
    )
    correlation_window_length = sgqlc.types.Field(
        Milliseconds, graphql_name="correlationWindowLength"
    )

    expression = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsRuleExpressionInput), graphql_name="expression"
    )

    min_correlation_threshold = sgqlc.types.Field(
        Int, graphql_name="minCorrelationThreshold"
    )

    retention_window_length = sgqlc.types.Field(
        Milliseconds, graphql_name="retentionWindowLength"
    )

class AiDecisionsSuggestionBlueprint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "correlation_window_length",
        "description",
        "hash",
        "min_correlation_threshold",
        "name",
        "override_configuration",
        "rule_expression",
        "suggester",
        "support",
    )
    correlation_window_length = sgqlc.types.Field(
        Milliseconds, graphql_name="correlationWindowLength"
    )

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

    hash = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="hash")

    min_correlation_threshold = sgqlc.types.Field(
        Int, graphql_name="minCorrelationThreshold"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    override_configuration = sgqlc.types.Field(
        AiDecisionsOverrideConfigurationInput, graphql_name="overrideConfiguration"
    )

    rule_expression = sgqlc.types.Field(
        sgqlc.types.non_null(AiDecisionsRuleExpressionInput),
        graphql_name="ruleExpression",
    )

    suggester = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="suggester"
    )

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

class AiDecisionsWholeCosineDistanceInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("max_distance",)
    max_distance = sgqlc.types.Field(
        sgqlc.types.non_null(Float), graphql_name="maxDistance"
    )

class AiDecisionsWholeJaccardSimilarityInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("threshold",)
    threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="threshold")

class AiIssuesFilterIncidents(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("entity_guids", "entity_types", "ids", "priority", "states")
    entity_guids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(EntityGuid)),
        graphql_name="entityGuids",
    )

    entity_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entityTypes"
    )

    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

    priority = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="priority"
    )

    states = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AiIssuesIncidentState)),
        graphql_name="states",
    )

class AiIssuesFilterIncidentsEvents(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("entity_guids", "entity_types", "ids")
    entity_guids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(EntityGuid)),
        graphql_name="entityGuids",
    )

    entity_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entityTypes"
    )

    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

class AiIssuesFilterIssues(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "condition_ids",
        "contains",
        "entity_guids",
        "entity_types",
        "ids",
        "is_acknowledged",
        "is_correlated",
        "muting_states",
        "policy_ids",
        "priority",
        "sources",
        "states",
    )
    condition_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Int)), graphql_name="conditionIds"
    )

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

    entity_guids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(EntityGuid)),
        graphql_name="entityGuids",
    )

    entity_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entityTypes"
    )

    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

    is_acknowledged = sgqlc.types.Field(Boolean, graphql_name="isAcknowledged")

    is_correlated = sgqlc.types.Field(Boolean, graphql_name="isCorrelated")

    muting_states = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AiIssuesIssueMutingState)),
        graphql_name="mutingStates",
    )

    policy_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Int)), graphql_name="policyIds"
    )

    priority = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="priority"
    )

    sources = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="sources"
    )

    states = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AiIssuesIssueState)),
        graphql_name="states",
    )

class AiIssuesFilterIssuesEvents(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("entity_guids", "entity_types", "ids", "states")
    entity_guids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(EntityGuid)),
        graphql_name="entityGuids",
    )

    entity_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="entityTypes"
    )

    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

    states = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AiIssuesIssueState)),
        graphql_name="states",
    )

class AiIssuesGracePeriodConfigurationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("critical", "high", "low", "medium")
    critical = sgqlc.types.Field(sgqlc.types.non_null(Seconds), graphql_name="critical")

    high = sgqlc.types.Field(sgqlc.types.non_null(Seconds), graphql_name="high")

    low = sgqlc.types.Field(sgqlc.types.non_null(Seconds), graphql_name="low")

    medium = sgqlc.types.Field(sgqlc.types.non_null(Seconds), graphql_name="medium")

class AiNotificationsBasicAuthInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("password", "user")
    password = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="password"
    )

    user = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="user")

class AiNotificationsChannelFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "active",
        "destination_id",
        "id",
        "ids",
        "name",
        "product",
        "property",
        "statuses",
        "type",
    )
    active = sgqlc.types.Field(Boolean, graphql_name="active")

    destination_id = sgqlc.types.Field(ID, graphql_name="destinationId")

    id = sgqlc.types.Field(ID, graphql_name="id")

    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

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

    product = sgqlc.types.Field(AiNotificationsProduct, graphql_name="product")

    property = sgqlc.types.Field(
        "AiNotificationsPropertyFilter", graphql_name="property"
    )

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

    type = sgqlc.types.Field(AiNotificationsChannelType, graphql_name="type")

class AiNotificationsChannelInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("destination_id", "name", "product", "properties", "type")
    destination_id = sgqlc.types.Field(
        sgqlc.types.non_null(ID), graphql_name="destinationId"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    product = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsProduct), graphql_name="product"
    )

    properties = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AiNotificationsPropertyInput"))
        ),
        graphql_name="properties",
    )

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsChannelType), graphql_name="type"
    )

class AiNotificationsChannelSorter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("direction", "field")
    direction = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsSortOrder), graphql_name="direction"
    )

    field = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsChannelFields), graphql_name="field"
    )

class AiNotificationsChannelUpdate(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("active", "name", "properties")
    active = sgqlc.types.Field(Boolean, graphql_name="active")

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

    properties = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("AiNotificationsPropertyInput")),
        graphql_name="properties",
    )

class AiNotificationsConstraint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiNotificationsCredentialsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("basic", "custom_headers", "oauth2", "token", "type")
    basic = sgqlc.types.Field(AiNotificationsBasicAuthInput, graphql_name="basic")

    custom_headers = sgqlc.types.Field(
        "AiNotificationsCustomHeadersAuthInput", graphql_name="customHeaders"
    )

    oauth2 = sgqlc.types.Field("AiNotificationsOAuth2AuthInput", graphql_name="oauth2")

    token = sgqlc.types.Field("AiNotificationsTokenAuthInput", graphql_name="token")

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsAuthType), graphql_name="type"
    )

class AiNotificationsCustomHeaderInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")

    value = sgqlc.types.Field(SecureValue, graphql_name="value")

class AiNotificationsCustomHeadersAuthInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("custom_headers",)
    custom_headers = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(AiNotificationsCustomHeaderInput))
        ),
        graphql_name="customHeaders",
    )

class AiNotificationsDestinationFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "active",
        "auth_type",
        "exact_name",
        "id",
        "ids",
        "name",
        "property",
        "scope_types",
        "type",
        "updated_at",
    )
    active = sgqlc.types.Field(Boolean, graphql_name="active")

    auth_type = sgqlc.types.Field(AiNotificationsAuthType, graphql_name="authType")

    exact_name = sgqlc.types.Field(String, graphql_name="exactName")

    id = sgqlc.types.Field(ID, graphql_name="id")

    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

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

    property = sgqlc.types.Field(
        "AiNotificationsPropertyFilter", graphql_name="property"
    )

    scope_types = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AiNotificationsEntityScopeTypeInput)),
        graphql_name="scopeTypes",
    )

    type = sgqlc.types.Field(AiNotificationsDestinationType, graphql_name="type")

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")

class AiNotificationsDestinationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("auth", "name", "properties", "secure_url", "type")
    auth = sgqlc.types.Field(AiNotificationsCredentialsInput, graphql_name="auth")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    properties = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AiNotificationsPropertyInput"))
        ),
        graphql_name="properties",
    )

    secure_url = sgqlc.types.Field(
        "AiNotificationsSecureUrlInput", graphql_name="secureUrl"
    )

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsDestinationType), graphql_name="type"
    )

class AiNotificationsDestinationSorter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("direction", "field")
    direction = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsSortOrder), graphql_name="direction"
    )

    field = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsDestinationFields), graphql_name="field"
    )

class AiNotificationsDestinationUpdate(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "active",
        "auth",
        "disable_auth",
        "name",
        "properties",
        "secure_url",
    )
    active = sgqlc.types.Field(Boolean, graphql_name="active")

    auth = sgqlc.types.Field(AiNotificationsCredentialsInput, graphql_name="auth")

    disable_auth = sgqlc.types.Field(Boolean, graphql_name="disableAuth")

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

    properties = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("AiNotificationsPropertyInput")),
        graphql_name="properties",
    )

    secure_url = sgqlc.types.Field(
        "AiNotificationsSecureUrlUpdate", graphql_name="secureUrl"
    )

class AiNotificationsDynamicVariable(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("example_value", "name")
    example_value = sgqlc.types.Field(
        "AiNotificationsExampleValue", graphql_name="exampleValue"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AiNotificationsEntityScopeInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("id", "type")
    id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="id")

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsEntityScopeTypeInput), graphql_name="type"
    )

class AiNotificationsExampleValue(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("example", "type")
    example = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="example")

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsVariableType), graphql_name="type"
    )

class AiNotificationsOAuth2AuthInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "access_token_url",
        "authorization_url",
        "client_id",
        "client_secret",
        "prefix",
        "refresh_interval",
        "refresh_token",
        "refreshable",
        "scope",
        "token",
    )
    access_token_url = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="accessTokenUrl"
    )

    authorization_url = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="authorizationUrl"
    )

    client_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="clientId")

    client_secret = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="clientSecret"
    )

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

    refresh_interval = sgqlc.types.Field(Int, graphql_name="refreshInterval")

    refresh_token = sgqlc.types.Field(SecureValue, graphql_name="refreshToken")

    refreshable = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="refreshable"
    )

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

    token = sgqlc.types.Field(sgqlc.types.non_null(SecureValue), graphql_name="token")

class AiNotificationsPropertyFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiNotificationsPropertyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("display_value", "key", "label", "value")
    display_value = sgqlc.types.Field(String, graphql_name="displayValue")

    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")

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

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiNotificationsSecureUrlInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("prefix", "secure_suffix")
    prefix = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="prefix")

    secure_suffix = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="secureSuffix"
    )

class AiNotificationsSecureUrlUpdate(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("prefix", "secure_suffix")
    prefix = sgqlc.types.Field(String, graphql_name="prefix")

    secure_suffix = sgqlc.types.Field(SecureValue, graphql_name="secureSuffix")

class AiNotificationsSuggestionFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("type", "value")
    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsSuggestionFilterType), graphql_name="type"
    )

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiNotificationsTokenAuthInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("prefix", "token")
    prefix = sgqlc.types.Field(String, graphql_name="prefix")

    token = sgqlc.types.Field(sgqlc.types.non_null(SecureValue), graphql_name="token")

class AiNotificationsUnverifiedEmailsFilters(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("emails", "statuses", "updated_at")
    emails = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="emails"
    )

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

    updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt")

class AiNotificationsUnverifiedEmailsSorter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("direction", "field")
    direction = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsSortOrder), graphql_name="direction"
    )

    field = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsUnverifiedEmailsFields),
        graphql_name="field",
    )

class AiNotificationsVariableFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("active", "key", "label", "name", "product")
    active = sgqlc.types.Field(Boolean, graphql_name="active")

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

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

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

    product = sgqlc.types.Field(AiNotificationsProduct, graphql_name="product")

class AiNotificationsVariableSorter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("direction", "field")
    direction = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsSortOrder), graphql_name="direction"
    )

    field = sgqlc.types.Field(
        sgqlc.types.non_null(AiNotificationsVariableFields), graphql_name="field"
    )

class AiTopologyCollectorAttributeInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key", "value")
    key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key")

    value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value")

class AiTopologyCollectorEdgeBlueprint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("directed", "from_vertex_name", "to_vertex_name")
    directed = sgqlc.types.Field(Boolean, graphql_name="directed")

    from_vertex_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="fromVertexName"
    )

    to_vertex_name = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="toVertexName"
    )

class AiTopologyCollectorVertexBlueprint(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("defining_attributes", "name", "vertex_class")
    defining_attributes = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(AiTopologyCollectorAttributeInput))
        ),
        graphql_name="definingAttributes",
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    vertex_class = sgqlc.types.Field(
        sgqlc.types.non_null(AiTopologyCollectorVertexClass), graphql_name="vertexClass"
    )

class AiWorkflowsCreateWorkflowInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "destination_configurations",
        "destinations_enabled",
        "enrichments",
        "enrichments_enabled",
        "issues_filter",
        "muting_rules_handling",
        "name",
        "workflow_enabled",
    )
    destination_configurations = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(
                sgqlc.types.non_null("AiWorkflowsDestinationConfigurationInput")
            )
        ),
        graphql_name="destinationConfigurations",
    )

    destinations_enabled = sgqlc.types.Field(
        Boolean, graphql_name="destinationsEnabled"
    )

    enrichments = sgqlc.types.Field(
        "AiWorkflowsEnrichmentsInput", graphql_name="enrichments"
    )

    enrichments_enabled = sgqlc.types.Field(Boolean, graphql_name="enrichmentsEnabled")

    issues_filter = sgqlc.types.Field(
        "AiWorkflowsFilterInput", graphql_name="issuesFilter"
    )

    muting_rules_handling = sgqlc.types.Field(
        sgqlc.types.non_null(AiWorkflowsMutingRulesHandling),
        graphql_name="mutingRulesHandling",
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    workflow_enabled = sgqlc.types.Field(Boolean, graphql_name="workflowEnabled")

class AiWorkflowsDestinationConfigurationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("channel_id", "notification_triggers", "update_original_message")
    channel_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="channelId")

    notification_triggers = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AiWorkflowsNotificationTrigger)),
        graphql_name="notificationTriggers",
    )

    update_original_message = sgqlc.types.Field(
        Boolean, graphql_name="updateOriginalMessage"
    )

class AiWorkflowsEnrichmentsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("nrql",)
    nrql = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AiWorkflowsNrqlEnrichmentInput"))
        ),
        graphql_name="nrql",
    )

class AiWorkflowsFilterInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("name", "predicates", "type")
    name = sgqlc.types.Field(String, graphql_name="name")

    predicates = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AiWorkflowsPredicateInput"))
        ),
        graphql_name="predicates",
    )

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AiWorkflowsFilterType), graphql_name="type"
    )

class AiWorkflowsFilters(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "channel_id",
        "destination_type",
        "enrichment_id",
        "filter_id",
        "guid",
        "id",
        "name",
        "name_like",
        "workflow_enabled",
    )
    channel_id = sgqlc.types.Field(ID, graphql_name="channelId")

    destination_type = sgqlc.types.Field(
        AiWorkflowsDestinationType, graphql_name="destinationType"
    )

    enrichment_id = sgqlc.types.Field(ID, graphql_name="enrichmentId")

    filter_id = sgqlc.types.Field(ID, graphql_name="filterId")

    guid = sgqlc.types.Field(EntityGuid, graphql_name="guid")

    id = sgqlc.types.Field(ID, graphql_name="id")

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

    name_like = sgqlc.types.Field(String, graphql_name="nameLike")

    workflow_enabled = sgqlc.types.Field(Boolean, graphql_name="workflowEnabled")

class AiWorkflowsNrqlConfigurationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("query",)
    query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="query")

class AiWorkflowsNrqlEnrichmentInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("configuration", "name")
    configuration = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(AiWorkflowsNrqlConfigurationInput))
        ),
        graphql_name="configuration",
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AiWorkflowsNrqlTestEnrichmentInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("configuration", "id", "name")
    configuration = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(AiWorkflowsNrqlConfigurationInput))
        ),
        graphql_name="configuration",
    )

    id = sgqlc.types.Field(ID, graphql_name="id")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AiWorkflowsNrqlUpdateEnrichmentInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("configuration", "id", "name")
    configuration = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null(AiWorkflowsNrqlConfigurationInput))
        ),
        graphql_name="configuration",
    )

    id = sgqlc.types.Field(ID, graphql_name="id")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AiWorkflowsPredicateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("attribute", "operator", "values")
    attribute = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="attribute"
    )

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(AiWorkflowsOperator), graphql_name="operator"
    )

    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="values",
    )

class AiWorkflowsTestEnrichmentsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("nrql",)
    nrql = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(
                sgqlc.types.non_null(AiWorkflowsNrqlTestEnrichmentInput)
            )
        ),
        graphql_name="nrql",
    )

class AiWorkflowsTestWorkflowInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("destination_configurations", "enrichments", "issues_filter")
    destination_configurations = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(
                sgqlc.types.non_null(AiWorkflowsDestinationConfigurationInput)
            )
        ),
        graphql_name="destinationConfigurations",
    )

    enrichments = sgqlc.types.Field(
        AiWorkflowsTestEnrichmentsInput, graphql_name="enrichments"
    )

    issues_filter = sgqlc.types.Field(
        AiWorkflowsFilterInput, graphql_name="issuesFilter"
    )

class AiWorkflowsUpdateEnrichmentsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("nrql",)
    nrql = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(
                sgqlc.types.non_null(AiWorkflowsNrqlUpdateEnrichmentInput)
            )
        ),
        graphql_name="nrql",
    )

class AiWorkflowsUpdateWorkflowInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "destination_configurations",
        "destinations_enabled",
        "enrichments",
        "enrichments_enabled",
        "id",
        "issues_filter",
        "muting_rules_handling",
        "name",
        "workflow_enabled",
    )
    destination_configurations = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AiWorkflowsDestinationConfigurationInput)
        ),
        graphql_name="destinationConfigurations",
    )

    destinations_enabled = sgqlc.types.Field(
        Boolean, graphql_name="destinationsEnabled"
    )

    enrichments = sgqlc.types.Field(
        AiWorkflowsUpdateEnrichmentsInput, graphql_name="enrichments"
    )

    enrichments_enabled = sgqlc.types.Field(Boolean, graphql_name="enrichmentsEnabled")

    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    issues_filter = sgqlc.types.Field(
        "AiWorkflowsUpdatedFilterInput", graphql_name="issuesFilter"
    )

    muting_rules_handling = sgqlc.types.Field(
        AiWorkflowsMutingRulesHandling, graphql_name="mutingRulesHandling"
    )

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

    workflow_enabled = sgqlc.types.Field(Boolean, graphql_name="workflowEnabled")

class AiWorkflowsUpdatedFilterInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("filter_input", "id")
    filter_input = sgqlc.types.Field(
        sgqlc.types.non_null(AiWorkflowsFilterInput), graphql_name="filterInput"
    )

    id = sgqlc.types.Field(ID, graphql_name="id")

class AlertsAsNrqlConditionsSearchCriteriaInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "name",
        "name_like",
        "policy_id",
        "source_product",
        "terms_operator",
    )
    name = sgqlc.types.Field(String, graphql_name="name")

    name_like = sgqlc.types.Field(String, graphql_name="nameLike")

    policy_id = sgqlc.types.Field(ID, graphql_name="policyId")

    source_product = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertsAsNrqlSourceProduct)),
        graphql_name="sourceProduct",
    )

    terms_operator = sgqlc.types.Field(
        AlertsNrqlConditionTermsOperator, graphql_name="termsOperator"
    )

class AlertsCompoundConditionFilterInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("id",)
    id = sgqlc.types.Field("AlertsCompoundConditionIdInput", graphql_name="id")

class AlertsCompoundConditionIdInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("eq", "in_")
    eq = sgqlc.types.Field(ID, graphql_name="eq")

    in_ = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="in"
    )

class AlertsCompoundConditionSortInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("direction", "key")
    direction = sgqlc.types.Field(
        AlertsCompoundConditionSortDirection, graphql_name="direction"
    )

    key = sgqlc.types.Field(AlertsCompoundConditionSortKey, graphql_name="key")

class AlertsEmailNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("emails", "include_json", "name")
    emails = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))),
        graphql_name="emails",
    )

    include_json = sgqlc.types.Field(
        sgqlc.types.non_null(Boolean), graphql_name="includeJson"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AlertsEmailNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("emails", "include_json", "name")
    emails = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="emails"
    )

    include_json = sgqlc.types.Field(Boolean, graphql_name="includeJson")

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

class AlertsMutingRuleConditionGroupInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("conditions", "operator")
    conditions = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(sgqlc.types.non_null("AlertsMutingRuleConditionInput"))
        ),
        graphql_name="conditions",
    )

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsMutingRuleConditionGroupOperator),
        graphql_name="operator",
    )

class AlertsMutingRuleConditionInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("attribute", "operator", "values")
    attribute = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="attribute"
    )

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsMutingRuleConditionOperator), graphql_name="operator"
    )

    values = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="values"
    )

class AlertsMutingRuleInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "action_on_muting_rule_window_ended",
        "condition",
        "description",
        "enabled",
        "name",
        "schedule",
    )
    action_on_muting_rule_window_ended = sgqlc.types.Field(
        AlertsActionOnMutingRuleWindowEnded,
        graphql_name="actionOnMutingRuleWindowEnded",
    )

    condition = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsMutingRuleConditionGroupInput),
        graphql_name="condition",
    )

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

    enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="enabled")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    schedule = sgqlc.types.Field(
        "AlertsMutingRuleScheduleInput", graphql_name="schedule"
    )

class AlertsMutingRuleScheduleInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "end_repeat",
        "end_time",
        "repeat",
        "repeat_count",
        "start_time",
        "time_zone",
        "weekly_repeat_days",
    )
    end_repeat = sgqlc.types.Field(NaiveDateTime, graphql_name="endRepeat")

    end_time = sgqlc.types.Field(NaiveDateTime, graphql_name="endTime")

    repeat = sgqlc.types.Field(AlertsMutingRuleScheduleRepeat, graphql_name="repeat")

    repeat_count = sgqlc.types.Field(Int, graphql_name="repeatCount")

    start_time = sgqlc.types.Field(NaiveDateTime, graphql_name="startTime")

    time_zone = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="timeZone")

    weekly_repeat_days = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertsDayOfWeek)),
        graphql_name="weeklyRepeatDays",
    )

class AlertsMutingRuleScheduleUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "end_repeat",
        "end_time",
        "repeat",
        "repeat_count",
        "start_time",
        "time_zone",
        "weekly_repeat_days",
    )
    end_repeat = sgqlc.types.Field(NaiveDateTime, graphql_name="endRepeat")

    end_time = sgqlc.types.Field(NaiveDateTime, graphql_name="endTime")

    repeat = sgqlc.types.Field(AlertsMutingRuleScheduleRepeat, graphql_name="repeat")

    repeat_count = sgqlc.types.Field(Int, graphql_name="repeatCount")

    start_time = sgqlc.types.Field(NaiveDateTime, graphql_name="startTime")

    time_zone = sgqlc.types.Field(String, graphql_name="timeZone")

    weekly_repeat_days = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertsDayOfWeek)),
        graphql_name="weeklyRepeatDays",
    )

class AlertsMutingRuleUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "action_on_muting_rule_window_ended",
        "condition",
        "description",
        "enabled",
        "name",
        "schedule",
    )
    action_on_muting_rule_window_ended = sgqlc.types.Field(
        AlertsActionOnMutingRuleWindowEnded,
        graphql_name="actionOnMutingRuleWindowEnded",
    )

    condition = sgqlc.types.Field(
        AlertsMutingRuleConditionGroupInput, graphql_name="condition"
    )

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

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

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

    schedule = sgqlc.types.Field(
        AlertsMutingRuleScheduleUpdateInput, graphql_name="schedule"
    )

class AlertsMutingRulesFilterCriteriaInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("enabled",)
    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

class AlertsNotificationChannelCreateConfiguration(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "email",
        "ops_genie",
        "pager_duty",
        "slack",
        "victor_ops",
        "webhook",
        "x_matters",
    )
    email = sgqlc.types.Field(
        AlertsEmailNotificationChannelCreateInput, graphql_name="email"
    )

    ops_genie = sgqlc.types.Field(
        "AlertsOpsGenieNotificationChannelCreateInput", graphql_name="opsGenie"
    )

    pager_duty = sgqlc.types.Field(
        "AlertsPagerDutyNotificationChannelCreateInput", graphql_name="pagerDuty"
    )

    slack = sgqlc.types.Field(
        "AlertsSlackNotificationChannelCreateInput", graphql_name="slack"
    )

    victor_ops = sgqlc.types.Field(
        "AlertsVictorOpsNotificationChannelCreateInput", graphql_name="victorOps"
    )

    webhook = sgqlc.types.Field(
        "AlertsWebhookNotificationChannelCreateInput", graphql_name="webhook"
    )

    x_matters = sgqlc.types.Field(
        "AlertsXMattersNotificationChannelCreateInput", graphql_name="xMatters"
    )

class AlertsNotificationChannelUpdateConfiguration(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "email",
        "ops_genie",
        "pager_duty",
        "slack",
        "victor_ops",
        "webhook",
        "x_matters",
    )
    email = sgqlc.types.Field(
        AlertsEmailNotificationChannelUpdateInput, graphql_name="email"
    )

    ops_genie = sgqlc.types.Field(
        "AlertsOpsGenieNotificationChannelUpdateInput", graphql_name="opsGenie"
    )

    pager_duty = sgqlc.types.Field(
        "AlertsPagerDutyNotificationChannelUpdateInput", graphql_name="pagerDuty"
    )

    slack = sgqlc.types.Field(
        "AlertsSlackNotificationChannelUpdateInput", graphql_name="slack"
    )

    victor_ops = sgqlc.types.Field(
        "AlertsVictorOpsNotificationChannelUpdateInput", graphql_name="victorOps"
    )

    webhook = sgqlc.types.Field(
        "AlertsWebhookNotificationChannelUpdateInput", graphql_name="webhook"
    )

    x_matters = sgqlc.types.Field(
        "AlertsXMattersNotificationChannelUpdateInput", graphql_name="xMatters"
    )

class AlertsNrqlConditionBaselineInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "baseline_direction",
        "description",
        "enabled",
        "expiration",
        "name",
        "nrql",
        "runbook_url",
        "signal",
        "signal_seasonality",
        "target_entity",
        "terms",
        "title_template",
        "violation_time_limit",
        "violation_time_limit_seconds",
    )
    baseline_direction = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlBaselineDirection),
        graphql_name="baselineDirection",
    )

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

    enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="enabled")

    expiration = sgqlc.types.Field(
        "AlertsNrqlConditionExpirationInput", graphql_name="expiration"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    nrql = sgqlc.types.Field(
        sgqlc.types.non_null("AlertsNrqlConditionQueryInput"), graphql_name="nrql"
    )

    runbook_url = sgqlc.types.Field(String, graphql_name="runbookUrl")

    signal = sgqlc.types.Field("AlertsNrqlConditionSignalInput", graphql_name="signal")

    signal_seasonality = sgqlc.types.Field(
        AlertsNrqlSignalSeasonality, graphql_name="signalSeasonality"
    )

    target_entity = sgqlc.types.Field(EntityGuid, graphql_name="targetEntity")

    terms = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null("AlertsNrqlDynamicConditionTermsInput")
        ),
        graphql_name="terms",
    )

    title_template = sgqlc.types.Field(String, graphql_name="titleTemplate")

    violation_time_limit = sgqlc.types.Field(
        AlertsViolationTimeLimit, graphql_name="violationTimeLimit"
    )

    violation_time_limit_seconds = sgqlc.types.Field(
        Seconds, graphql_name="violationTimeLimitSeconds"
    )

class AlertsNrqlConditionExpirationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "close_violations_on_expiration",
        "expiration_duration",
        "ignore_on_expected_termination",
        "open_violation_on_expiration",
    )
    close_violations_on_expiration = sgqlc.types.Field(
        Boolean, graphql_name="closeViolationsOnExpiration"
    )

    expiration_duration = sgqlc.types.Field(Seconds, graphql_name="expirationDuration")

    ignore_on_expected_termination = sgqlc.types.Field(
        Boolean, graphql_name="ignoreOnExpectedTermination"
    )

    open_violation_on_expiration = sgqlc.types.Field(
        Boolean, graphql_name="openViolationOnExpiration"
    )

class AlertsNrqlConditionOutlierInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "description",
        "enabled",
        "expiration",
        "name",
        "nrql",
        "outlier_configuration",
        "runbook_url",
        "signal",
        "target_entity",
        "terms",
        "title_template",
        "violation_time_limit",
        "violation_time_limit_seconds",
    )
    description = sgqlc.types.Field(String, graphql_name="description")

    enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="enabled")

    expiration = sgqlc.types.Field(
        AlertsNrqlConditionExpirationInput, graphql_name="expiration"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    nrql = sgqlc.types.Field(
        sgqlc.types.non_null("AlertsNrqlConditionQueryInput"), graphql_name="nrql"
    )

    outlier_configuration = sgqlc.types.Field(
        "AlertsOutlierConfigurationInput", graphql_name="outlierConfiguration"
    )

    runbook_url = sgqlc.types.Field(String, graphql_name="runbookUrl")

    signal = sgqlc.types.Field("AlertsNrqlConditionSignalInput", graphql_name="signal")

    target_entity = sgqlc.types.Field(EntityGuid, graphql_name="targetEntity")

    terms = sgqlc.types.Field(
        sgqlc.types.non_null(
            sgqlc.types.list_of(
                sgqlc.types.non_null("AlertsNrqlDynamicConditionTermsInput")
            )
        ),
        graphql_name="terms",
    )

    title_template = sgqlc.types.Field(String, graphql_name="titleTemplate")

    violation_time_limit = sgqlc.types.Field(
        AlertsViolationTimeLimit, graphql_name="violationTimeLimit"
    )

    violation_time_limit_seconds = sgqlc.types.Field(
        Seconds, graphql_name="violationTimeLimitSeconds"
    )

class AlertsNrqlConditionPredictionInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("predict_by", "prefer_prediction_violation")
    predict_by = sgqlc.types.Field(Seconds, graphql_name="predictBy")

    prefer_prediction_violation = sgqlc.types.Field(
        Boolean, graphql_name="preferPredictionViolation"
    )

class AlertsNrqlConditionQueryInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("data_account_id", "evaluation_offset", "query")
    data_account_id = sgqlc.types.Field(Int, graphql_name="dataAccountId")

    evaluation_offset = sgqlc.types.Field(Int, graphql_name="evaluationOffset")

    query = sgqlc.types.Field(sgqlc.types.non_null(Nrql), graphql_name="query")

class AlertsNrqlConditionSignalInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "aggregation_delay",
        "aggregation_method",
        "aggregation_timer",
        "aggregation_window",
        "evaluation_delay",
        "evaluation_offset",
        "fill_option",
        "fill_value",
        "polling_frequency",
        "slide_by",
    )
    aggregation_delay = sgqlc.types.Field(Seconds, graphql_name="aggregationDelay")

    aggregation_method = sgqlc.types.Field(
        AlertsSignalAggregationMethod, graphql_name="aggregationMethod"
    )

    aggregation_timer = sgqlc.types.Field(Seconds, graphql_name="aggregationTimer")

    aggregation_window = sgqlc.types.Field(Seconds, graphql_name="aggregationWindow")

    evaluation_delay = sgqlc.types.Field(Seconds, graphql_name="evaluationDelay")

    evaluation_offset = sgqlc.types.Field(Int, graphql_name="evaluationOffset")

    fill_option = sgqlc.types.Field(AlertsFillOption, graphql_name="fillOption")

    fill_value = sgqlc.types.Field(Float, graphql_name="fillValue")

    polling_frequency = sgqlc.types.Field(Seconds, graphql_name="pollingFrequency")

    slide_by = sgqlc.types.Field(Seconds, graphql_name="slideBy")

class AlertsNrqlConditionStaticInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "description",
        "enabled",
        "expiration",
        "name",
        "nrql",
        "runbook_url",
        "signal",
        "target_entity",
        "terms",
        "title_template",
        "value_function",
        "violation_time_limit",
        "violation_time_limit_seconds",
    )
    description = sgqlc.types.Field(String, graphql_name="description")

    enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="enabled")

    expiration = sgqlc.types.Field(
        AlertsNrqlConditionExpirationInput, graphql_name="expiration"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    nrql = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlConditionQueryInput), graphql_name="nrql"
    )

    runbook_url = sgqlc.types.Field(String, graphql_name="runbookUrl")

    signal = sgqlc.types.Field(AlertsNrqlConditionSignalInput, graphql_name="signal")

    target_entity = sgqlc.types.Field(EntityGuid, graphql_name="targetEntity")

    terms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null("AlertsNrqlConditionTermsInput")),
        graphql_name="terms",
    )

    title_template = sgqlc.types.Field(String, graphql_name="titleTemplate")

    value_function = sgqlc.types.Field(
        AlertsNrqlStaticConditionValueFunction, graphql_name="valueFunction"
    )

    violation_time_limit = sgqlc.types.Field(
        AlertsViolationTimeLimit, graphql_name="violationTimeLimit"
    )

    violation_time_limit_seconds = sgqlc.types.Field(
        Seconds, graphql_name="violationTimeLimitSeconds"
    )

class AlertsNrqlConditionTermsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "disable_health_status_reporting",
        "operator",
        "prediction",
        "priority",
        "threshold",
        "threshold_duration",
        "threshold_occurrences",
    )
    disable_health_status_reporting = sgqlc.types.Field(
        Boolean, graphql_name="disableHealthStatusReporting"
    )

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlConditionTermsOperator), graphql_name="operator"
    )

    prediction = sgqlc.types.Field(
        AlertsNrqlConditionPredictionInput, graphql_name="prediction"
    )

    priority = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlConditionPriority), graphql_name="priority"
    )

    threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="threshold")

    threshold_duration = sgqlc.types.Field(
        sgqlc.types.non_null(Seconds), graphql_name="thresholdDuration"
    )

    threshold_occurrences = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlConditionThresholdOccurrences),
        graphql_name="thresholdOccurrences",
    )

class AlertsNrqlConditionUpdateBaselineInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "baseline_direction",
        "description",
        "enabled",
        "expiration",
        "name",
        "nrql",
        "runbook_url",
        "signal",
        "signal_seasonality",
        "target_entity",
        "terms",
        "title_template",
        "violation_time_limit",
        "violation_time_limit_seconds",
    )
    baseline_direction = sgqlc.types.Field(
        AlertsNrqlBaselineDirection, graphql_name="baselineDirection"
    )

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

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    expiration = sgqlc.types.Field(
        AlertsNrqlConditionExpirationInput, graphql_name="expiration"
    )

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

    nrql = sgqlc.types.Field("AlertsNrqlConditionUpdateQueryInput", graphql_name="nrql")

    runbook_url = sgqlc.types.Field(String, graphql_name="runbookUrl")

    signal = sgqlc.types.Field(AlertsNrqlConditionSignalInput, graphql_name="signal")

    signal_seasonality = sgqlc.types.Field(
        AlertsNrqlSignalSeasonality, graphql_name="signalSeasonality"
    )

    target_entity = sgqlc.types.Field(EntityGuid, graphql_name="targetEntity")

    terms = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null("AlertsNrqlDynamicConditionTermsInput")
        ),
        graphql_name="terms",
    )

    title_template = sgqlc.types.Field(String, graphql_name="titleTemplate")

    violation_time_limit = sgqlc.types.Field(
        AlertsViolationTimeLimit, graphql_name="violationTimeLimit"
    )

    violation_time_limit_seconds = sgqlc.types.Field(
        Seconds, graphql_name="violationTimeLimitSeconds"
    )

class AlertsNrqlConditionUpdateOutlierInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "description",
        "enabled",
        "expiration",
        "name",
        "nrql",
        "outlier_configuration",
        "runbook_url",
        "signal",
        "target_entity",
        "terms",
        "title_template",
        "violation_time_limit",
        "violation_time_limit_seconds",
    )
    description = sgqlc.types.Field(String, graphql_name="description")

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    expiration = sgqlc.types.Field(
        AlertsNrqlConditionExpirationInput, graphql_name="expiration"
    )

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

    nrql = sgqlc.types.Field("AlertsNrqlConditionUpdateQueryInput", graphql_name="nrql")

    outlier_configuration = sgqlc.types.Field(
        "AlertsOutlierConfigurationInput", graphql_name="outlierConfiguration"
    )

    runbook_url = sgqlc.types.Field(String, graphql_name="runbookUrl")

    signal = sgqlc.types.Field(AlertsNrqlConditionSignalInput, graphql_name="signal")

    target_entity = sgqlc.types.Field(EntityGuid, graphql_name="targetEntity")

    terms = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null("AlertsNrqlDynamicConditionTermsInput")
        ),
        graphql_name="terms",
    )

    title_template = sgqlc.types.Field(String, graphql_name="titleTemplate")

    violation_time_limit = sgqlc.types.Field(
        AlertsViolationTimeLimit, graphql_name="violationTimeLimit"
    )

    violation_time_limit_seconds = sgqlc.types.Field(
        Seconds, graphql_name="violationTimeLimitSeconds"
    )

class AlertsNrqlConditionUpdateQueryInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("data_account_id", "evaluation_offset", "query")
    data_account_id = sgqlc.types.Field(Int, graphql_name="dataAccountId")

    evaluation_offset = sgqlc.types.Field(Int, graphql_name="evaluationOffset")

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

class AlertsNrqlConditionUpdateStaticInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "description",
        "enabled",
        "expiration",
        "name",
        "nrql",
        "runbook_url",
        "signal",
        "target_entity",
        "terms",
        "title_template",
        "value_function",
        "violation_time_limit",
        "violation_time_limit_seconds",
    )
    description = sgqlc.types.Field(String, graphql_name="description")

    enabled = sgqlc.types.Field(Boolean, graphql_name="enabled")

    expiration = sgqlc.types.Field(
        AlertsNrqlConditionExpirationInput, graphql_name="expiration"
    )

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

    nrql = sgqlc.types.Field(AlertsNrqlConditionUpdateQueryInput, graphql_name="nrql")

    runbook_url = sgqlc.types.Field(String, graphql_name="runbookUrl")

    signal = sgqlc.types.Field(AlertsNrqlConditionSignalInput, graphql_name="signal")

    target_entity = sgqlc.types.Field(EntityGuid, graphql_name="targetEntity")

    terms = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(AlertsNrqlConditionTermsInput)),
        graphql_name="terms",
    )

    title_template = sgqlc.types.Field(String, graphql_name="titleTemplate")

    value_function = sgqlc.types.Field(
        AlertsNrqlStaticConditionValueFunction, graphql_name="valueFunction"
    )

    violation_time_limit = sgqlc.types.Field(
        AlertsViolationTimeLimit, graphql_name="violationTimeLimit"
    )

    violation_time_limit_seconds = sgqlc.types.Field(
        Seconds, graphql_name="violationTimeLimitSeconds"
    )

class AlertsNrqlConditionsSearchCriteriaInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "name",
        "name_like",
        "policy_id",
        "query",
        "query_like",
        "terms_operator",
    )
    name = sgqlc.types.Field(String, graphql_name="name")

    name_like = sgqlc.types.Field(String, graphql_name="nameLike")

    policy_id = sgqlc.types.Field(ID, graphql_name="policyId")

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

    query_like = sgqlc.types.Field(String, graphql_name="queryLike")

    terms_operator = sgqlc.types.Field(
        AlertsNrqlConditionTermsOperator, graphql_name="termsOperator"
    )

class AlertsNrqlDynamicConditionTermsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "disable_health_status_reporting",
        "operator",
        "priority",
        "threshold",
        "threshold_duration",
        "threshold_occurrences",
    )
    disable_health_status_reporting = sgqlc.types.Field(
        Boolean, graphql_name="disableHealthStatusReporting"
    )

    operator = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlDynamicConditionTermsOperator),
        graphql_name="operator",
    )

    priority = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlConditionPriority), graphql_name="priority"
    )

    threshold = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="threshold")

    threshold_duration = sgqlc.types.Field(
        sgqlc.types.non_null(Seconds), graphql_name="thresholdDuration"
    )

    threshold_occurrences = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsNrqlConditionThresholdOccurrences),
        graphql_name="thresholdOccurrences",
    )

class AlertsOpsGenieNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "api_key",
        "data_center_region",
        "name",
        "recipients",
        "tags",
        "teams",
    )
    api_key = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="apiKey"
    )

    data_center_region = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsOpsGenieDataCenterRegion),
        graphql_name="dataCenterRegion",
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    recipients = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="recipients"
    )

    tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tags"
    )

    teams = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="teams"
    )

class AlertsOpsGenieNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "api_key",
        "data_center_region",
        "name",
        "recipients",
        "tags",
        "teams",
    )
    api_key = sgqlc.types.Field(SecureValue, graphql_name="apiKey")

    data_center_region = sgqlc.types.Field(
        AlertsOpsGenieDataCenterRegion, graphql_name="dataCenterRegion"
    )

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

    recipients = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="recipients"
    )

    tags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="tags"
    )

    teams = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="teams"
    )

class AlertsOutlierAlgorithmDbScanConfigurationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("epsilon", "evaluation_group_facet", "minimum_points")
    epsilon = sgqlc.types.Field(Float, graphql_name="epsilon")

    evaluation_group_facet = sgqlc.types.Field(
        String, graphql_name="evaluationGroupFacet"
    )

    minimum_points = sgqlc.types.Field(Int, graphql_name="minimumPoints")

class AlertsOutlierConfigurationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("dbscan",)
    dbscan = sgqlc.types.Field(
        AlertsOutlierAlgorithmDbScanConfigurationInput, graphql_name="dbscan"
    )

class AlertsPagerDutyNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("api_key", "name")
    api_key = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="apiKey"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AlertsPagerDutyNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("api_key", "name")
    api_key = sgqlc.types.Field(SecureValue, graphql_name="apiKey")

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

class AlertsPoliciesSearchCriteriaInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("ids", "name", "name_like")
    ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="ids"
    )

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

    name_like = sgqlc.types.Field(String, graphql_name="nameLike")

class AlertsPolicyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident_preference", "name")
    incident_preference = sgqlc.types.Field(
        sgqlc.types.non_null(AlertsIncidentPreference),
        graphql_name="incidentPreference",
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AlertsPolicyUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("incident_preference", "name")
    incident_preference = sgqlc.types.Field(
        AlertsIncidentPreference, graphql_name="incidentPreference"
    )

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

class AlertsSlackNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("name", "team_channel", "url")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    team_channel = sgqlc.types.Field(String, graphql_name="teamChannel")

    url = sgqlc.types.Field(sgqlc.types.non_null(SecureValue), graphql_name="url")

class AlertsSlackNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("name", "team_channel", "url")
    name = sgqlc.types.Field(String, graphql_name="name")

    team_channel = sgqlc.types.Field(String, graphql_name="teamChannel")

    url = sgqlc.types.Field(SecureValue, graphql_name="url")

class AlertsVictorOpsNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key", "name", "route_key")
    key = sgqlc.types.Field(sgqlc.types.non_null(SecureValue), graphql_name="key")

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    route_key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="routeKey")

class AlertsVictorOpsNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key", "name", "route_key")
    key = sgqlc.types.Field(SecureValue, graphql_name="key")

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

    route_key = sgqlc.types.Field(String, graphql_name="routeKey")

class AlertsWebhookBasicAuthMutationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("password", "username")
    password = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="password"
    )

    username = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="username")

class AlertsWebhookCustomHeaderMutationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("name", "value")
    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

    value = sgqlc.types.Field(sgqlc.types.non_null(SecureValue), graphql_name="value")

class AlertsWebhookNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "base_url",
        "basic_auth",
        "custom_http_headers",
        "custom_payload_body",
        "custom_payload_type",
        "name",
    )
    base_url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="baseUrl")

    basic_auth = sgqlc.types.Field(
        AlertsWebhookBasicAuthMutationInput, graphql_name="basicAuth"
    )

    custom_http_headers = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AlertsWebhookCustomHeaderMutationInput)
        ),
        graphql_name="customHttpHeaders",
    )

    custom_payload_body = sgqlc.types.Field(String, graphql_name="customPayloadBody")

    custom_payload_type = sgqlc.types.Field(
        AlertsWebhookCustomPayloadType, graphql_name="customPayloadType"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AlertsWebhookNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "base_url",
        "basic_auth",
        "custom_http_headers",
        "custom_payload_body",
        "custom_payload_type",
        "name",
    )
    base_url = sgqlc.types.Field(String, graphql_name="baseUrl")

    basic_auth = sgqlc.types.Field(
        AlertsWebhookBasicAuthMutationInput, graphql_name="basicAuth"
    )

    custom_http_headers = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AlertsWebhookCustomHeaderMutationInput)
        ),
        graphql_name="customHttpHeaders",
    )

    custom_payload_body = sgqlc.types.Field(String, graphql_name="customPayloadBody")

    custom_payload_type = sgqlc.types.Field(
        AlertsWebhookCustomPayloadType, graphql_name="customPayloadType"
    )

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

class AlertsXMattersNotificationChannelCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("integration_url", "name")
    integration_url = sgqlc.types.Field(
        sgqlc.types.non_null(SecureValue), graphql_name="integrationUrl"
    )

    name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name")

class AlertsXMattersNotificationChannelUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("integration_url", "name")
    integration_url = sgqlc.types.Field(SecureValue, graphql_name="integrationUrl")

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

class ApiAccessCreateIngestKeyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("account_id", "ingest_type", "name", "notes")
    account_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="accountId")

    ingest_type = sgqlc.types.Field(
        sgqlc.types.non_null(ApiAccessIngestKeyType), graphql_name="ingestType"
    )

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

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

class ApiAccessCreateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("ingest", "user")
    ingest = sgqlc.types.Field(
        sgqlc.types.list_of(ApiAccessCreateIngestKeyInput), graphql_name="ingest"
    )

    user = sgqlc.types.Field(
        sgqlc.types.list_of("ApiAccessCreateUserKeyInput"), graphql_name="user"
    )

class ApiAccessCreateUserKeyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("account_id", "name", "notes", "user_id")
    account_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="accountId")

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

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

    user_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="userId")

class ApiAccessDeleteInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("ingest_key_ids", "user_key_ids")
    ingest_key_ids = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="ingestKeyIds"
    )

    user_key_ids = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="userKeyIds"
    )

class ApiAccessKeySearchQuery(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("scope", "types")
    scope = sgqlc.types.Field("ApiAccessKeySearchScope", graphql_name="scope")

    types = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(ApiAccessKeyType)),
        graphql_name="types",
    )

class ApiAccessKeySearchScope(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("account_ids", "ingest_types", "user_ids")
    account_ids = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="accountIds")

    ingest_types = sgqlc.types.Field(
        sgqlc.types.list_of(ApiAccessIngestKeyType), graphql_name="ingestTypes"
    )

    user_ids = sgqlc.types.Field(sgqlc.types.list_of(Int), graphql_name="userIds")

class ApiAccessUpdateIngestKeyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key_id", "name", "notes")
    key_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="keyId")

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

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

class ApiAccessUpdateInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("ingest", "user")
    ingest = sgqlc.types.Field(
        sgqlc.types.list_of(ApiAccessUpdateIngestKeyInput), graphql_name="ingest"
    )

    user = sgqlc.types.Field(
        sgqlc.types.list_of("ApiAccessUpdateUserKeyInput"), graphql_name="user"
    )

class ApiAccessUpdateUserKeyInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("key_id", "name", "notes")
    key_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="keyId")

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

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

class ApmApplicationEntitySettings(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("apdex_target",)
    apdex_target = sgqlc.types.Field(Float, graphql_name="apdexTarget")

class AuthorizationManagementAccountAccessGrant(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("account_id", "data_access_policy_id", "role_id")
    account_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="accountId")

    data_access_policy_id = sgqlc.types.Field(ID, graphql_name="dataAccessPolicyId")

    role_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="roleId")

class AuthorizationManagementAccountAccessGrantUpdate(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("data_access_policy_id",)
    data_access_policy_id = sgqlc.types.Field(ID, graphql_name="dataAccessPolicyId")

class AuthorizationManagementEntity(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("id", "type")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

class AuthorizationManagementEntityAccessGrants(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("entity", "iam_parent", "role_id")
    entity = sgqlc.types.Field(
        sgqlc.types.non_null(AuthorizationManagementEntity), graphql_name="entity"
    )

    iam_parent = sgqlc.types.Field(
        "AuthorizationManagementIamParent", graphql_name="iamParent"
    )

    role_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="roleId")

class AuthorizationManagementGrantAccess(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "account_access_grants",
        "entity_access_grants",
        "grantee",
        "group_access_grants",
        "group_id",
        "organization_access_grants",
    )
    account_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AuthorizationManagementAccountAccessGrant)
        ),
        graphql_name="accountAccessGrants",
    )

    entity_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AuthorizationManagementEntityAccessGrants)
        ),
        graphql_name="entityAccessGrants",
    )

    grantee = sgqlc.types.Field(
        "AuthorizationManagementGrantee", graphql_name="grantee"
    )

    group_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null("AuthorizationManagementGroupAccessGrant")
        ),
        graphql_name="groupAccessGrants",
    )

    group_id = sgqlc.types.Field(ID, graphql_name="groupId")

    organization_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null("AuthorizationManagementOrganizationAccessGrant")
        ),
        graphql_name="organizationAccessGrants",
    )

class AuthorizationManagementGrantee(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("id", "type")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    type = sgqlc.types.Field(
        sgqlc.types.non_null(AuthorizationManagementGranteeTypeEnum),
        graphql_name="type",
    )

class AuthorizationManagementGroupAccessGrant(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("group_id", "role_id")
    group_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="groupId")

    role_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="roleId")

class AuthorizationManagementIamParent(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("id", "scope")
    id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id")

    scope = sgqlc.types.Field(
        sgqlc.types.non_null(AuthorizationManagementIamParentScopeTypeEnum),
        graphql_name="scope",
    )

class AuthorizationManagementOrganizationAccessGrant(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("role_id",)
    role_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="roleId")

class AuthorizationManagementRevokeAccess(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "account_access_grants",
        "entity_access_grants",
        "grantee",
        "group_access_grants",
        "group_id",
        "organization_access_grants",
    )
    account_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AuthorizationManagementAccountAccessGrant)
        ),
        graphql_name="accountAccessGrants",
    )

    entity_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AuthorizationManagementEntityAccessGrants)
        ),
        graphql_name="entityAccessGrants",
    )

    grantee = sgqlc.types.Field(AuthorizationManagementGrantee, graphql_name="grantee")

    group_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AuthorizationManagementGroupAccessGrant)
        ),
        graphql_name="groupAccessGrants",
    )

    group_id = sgqlc.types.Field(ID, graphql_name="groupId")

    organization_access_grants = sgqlc.types.Field(
        sgqlc.types.list_of(
            sgqlc.types.non_null(AuthorizationManagementOrganizationAccessGrant)
        ),
        graphql_name="organizationAccessGrants",
    )

class AuthorizationManagementUpdateAccess(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("account_access_grant", "ids")
    account_access_grant = sgqlc.types.Field(
        sgqlc.types.non_null(AuthorizationManagementAccountAccessGrantUpdate),
        graphql_name="accountAccessGrant",
    )

    ids = sgqlc.types.Field(
        sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))),
        graphql_name="ids",
    )

class ChangeTrackingCategoryAndTypeInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("category", "type")
    category = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="category")

    type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type")

class ChangeTrackingCategoryFieldsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("deployment", "feature_flag")
    deployment = sgqlc.types.Field(
        "ChangeTrackingDeploymentFieldsInput", graphql_name="deployment"
    )

    feature_flag = sgqlc.types.Field(
        "ChangeTrackingFeatureFlagFieldsInput", graphql_name="featureFlag"
    )

class ChangeTrackingCategoryRelatedInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("category_fields", "kind")
    category_fields = sgqlc.types.Field(
        ChangeTrackingCategoryFieldsInput, graphql_name="categoryFields"
    )

    kind = sgqlc.types.Field(
        sgqlc.types.non_null(ChangeTrackingCategoryAndTypeInput), graphql_name="kind"
    )

class ChangeTrackingChangeTrackingSearchFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("account_ids", "limit", "query", "time_window")
    account_ids = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(Int)), graphql_name="accountIds"
    )

    limit = sgqlc.types.Field(Int, graphql_name="limit")

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

    time_window = sgqlc.types.Field(
        "ChangeTrackingTimeWindowInputWithDefaults", graphql_name="timeWindow"
    )

class ChangeTrackingCreateEventInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "category_and_type_data",
        "custom_attributes",
        "description",
        "entity_search",
        "group_id",
        "short_description",
        "timestamp",
        "user",
    )
    category_and_type_data = sgqlc.types.Field(
        sgqlc.types.non_null(ChangeTrackingCategoryRelatedInput),
        graphql_name="categoryAndTypeData",
    )

    custom_attributes = sgqlc.types.Field(
        ChangeTrackingRawCustomAttributesMap, graphql_name="customAttributes"
    )

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

    entity_search = sgqlc.types.Field(
        sgqlc.types.non_null("ChangeTrackingEntitySearchInput"),
        graphql_name="entitySearch",
    )

    group_id = sgqlc.types.Field(String, graphql_name="groupId")

    short_description = sgqlc.types.Field(String, graphql_name="shortDescription")

    timestamp = sgqlc.types.Field(EpochMilliseconds, graphql_name="timestamp")

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

class ChangeTrackingDataHandlingRules(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("validation_flags",)
    validation_flags = sgqlc.types.Field(
        sgqlc.types.list_of(sgqlc.types.non_null(ChangeTrackingValidationFlag)),
        graphql_name="validationFlags",
    )

class ChangeTrackingDeploymentFieldsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("changelog", "commit", "deep_link", "version")
    changelog = sgqlc.types.Field(String, graphql_name="changelog")

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

    deep_link = sgqlc.types.Field(String, graphql_name="deepLink")

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

class ChangeTrackingDeploymentInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "changelog",
        "commit",
        "deep_link",
        "deployment_type",
        "description",
        "entity_guid",
        "group_id",
        "timestamp",
        "user",
        "version",
    )
    changelog = sgqlc.types.Field(String, graphql_name="changelog")

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

    deep_link = sgqlc.types.Field(String, graphql_name="deepLink")

    deployment_type = sgqlc.types.Field(
        ChangeTrackingDeploymentType, graphql_name="deploymentType"
    )

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

    entity_guid = sgqlc.types.Field(
        sgqlc.types.non_null(EntityGuid), graphql_name="entityGuid"
    )

    group_id = sgqlc.types.Field(String, graphql_name="groupId")

    timestamp = sgqlc.types.Field(EpochMilliseconds, graphql_name="timestamp")

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

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

class ChangeTrackingEntitySearchInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("query",)
    query = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="query")

class ChangeTrackingFeatureFlagFieldsInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("feature_flag_id",)
    feature_flag_id = sgqlc.types.Field(
        sgqlc.types.non_null(String), graphql_name="featureFlagId"
    )

class ChangeTrackingSearchFilter(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("limit", "query", "time_window")
    limit = sgqlc.types.Field(Int, graphql_name="limit")

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

    time_window = sgqlc.types.Field(
        "ChangeTrackingTimeWindowInputWithDefaults", graphql_name="timeWindow"
    )

class ChangeTrackingTimeWindowInputWithDefaults(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = ("end_time", "start_time")
    end_time = sgqlc.types.Field(EpochMilliseconds, graphql_name="endTime")

    start_time = sgqlc.types.Field(EpochMilliseconds, graphql_name="startTime")

class CloudAlbIntegrationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "aws_regions",
        "fetch_extended_inventory",
        "fetch_tags",
        "inventory_polling_interval",
        "linked_account_id",
        "load_balancer_prefixes",
        "metrics_polling_interval",
        "tag_key",
        "tag_value",
    )
    aws_regions = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="awsRegions"
    )

    fetch_extended_inventory = sgqlc.types.Field(
        Boolean, graphql_name="fetchExtendedInventory"
    )

    fetch_tags = sgqlc.types.Field(Boolean, graphql_name="fetchTags")

    inventory_polling_interval = sgqlc.types.Field(
        Int, graphql_name="inventoryPollingInterval"
    )

    linked_account_id = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="linkedAccountId"
    )

    load_balancer_prefixes = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="loadBalancerPrefixes"
    )

    metrics_polling_interval = sgqlc.types.Field(
        Int, graphql_name="metricsPollingInterval"
    )

    tag_key = sgqlc.types.Field(String, graphql_name="tagKey")

    tag_value = sgqlc.types.Field(String, graphql_name="tagValue")

class CloudApigatewayIntegrationInput(sgqlc.types.Input):
    __schema__ = nerdgraph
    __field_names__ = (
        "aws_regions",
        "inventory_polling_interval",
        "linked_account_id",
        "metrics_polling_interval",
        "stage_prefixes",
        "tag_key",
        "tag_value",
    )
    aws_regions = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="awsRegions"
    )

    inventory_polling_interval = sgqlc.types.Field(
        Int, graphql_name="inventoryPollingInterval"
    )

    linked_account_id = sgqlc.types.Field(
        sgqlc.types.non_null(Int), graphql_name="linkedAccountId"
    )

    metrics_polling_interval = sgqlc.types.Field(
        Int, graphql_name="metricsPollingInterval"
    )

    stage_prefixes = sgqlc.types.Field(
        sgqlc.types.list_of(String), graphql_name="stagePrefixes"
    )

    tag_key = sgqlc.types.Field(String, graphql_name="tagKey")

    tag_value = sgqlc.types.Field(String, graphql_name="tagValue")