diff --git a/.configs/gqlgen.yaml b/.configs/gqlgen.yaml index 02bfd6089..20b410861 100644 --- a/.configs/gqlgen.yaml +++ b/.configs/gqlgen.yaml @@ -76,6 +76,7 @@ autobind: - "github.com/nais/api/internal/workload/logging" - "github.com/nais/api/internal/workload/netpol" - "github.com/nais/api/internal/workload/podlog" + - "github.com/nais/api/internal/workload/configmap" - "github.com/nais/api/internal/workload/secret" # Don't generate Get functions for fields included in the GraphQL interfaces diff --git a/integration_tests/configs.lua b/integration_tests/configs.lua new file mode 100644 index 000000000..1c6e6912c --- /dev/null +++ b/integration_tests/configs.lua @@ -0,0 +1,1015 @@ +Helper.readK8sResources("k8s_resources/configs") + +local user = User.new("username-1", "user@example.com", "e") +local otherUser = User.new("username-2", "user2@example.com", "e2") + +local team = Team.new("myteam", "some purpose", "#channel") +team:addOwner(user) + +Test.gql("Create config for team that does not exist", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + createConfig(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "does-not-exist" + }) { + config { + id + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { + "createConfig", + }, + }, + }, + data = Null, + } +end) + +Test.gql("Create config that already exists", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + createConfig(input: { + name: "managed-config-in-dev" + environmentName: "dev" + teamSlug: "myteam" + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = "A config with this name already exists.", + path = { + "createConfig", + }, + }, + }, + data = Null, + } +end) + +Test.gql("Create config", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + createConfig(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + createConfig = { + config = { + name = "config-name", + values = {}, + }, + }, + }, + } +end) + +Test.gql("Add config value", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + addConfigValue(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "value-name", + value: "value" + } + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + addConfigValue = { + config = { + name = "config-name", + values = { + { + name = "value-name", + value = "value", + }, + }, + }, + }, + }, + } +end) + +Test.gql("Add config value that already exists", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + addConfigValue(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "value-name", + value: "value" + } + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("already contains a value with the name"), + path = { + "addConfigValue", + }, + }, + }, + data = Null, + } +end) + +Test.gql("Update config value", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + updateConfigValue(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "value-name", + value: "new value" + } + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + updateConfigValue = { + config = { + name = "config-name", + values = { + { + name = "value-name", + value = "new value", + }, + }, + }, + }, + }, + } +end) + +Test.gql("Update config value that does not exist", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + updateConfigValue(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "does-not-exist", + value: "new value" + } + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("does not contain a value with the name"), + path = { + "updateConfigValue", + }, + }, + }, + data = Null, + } +end) + +Test.gql("Remove config value that does not exist", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + removeConfigValue(input: { + configName: "config-name" + environmentName: "dev" + teamSlug: "myteam" + valueName: "foobar" + }) { + config { + name + } + } + } + ]] + + t.check { + data = Null, + errors = { + { + message = Contains("does not contain a value with the name"), + path = { + "removeConfigValue", + }, + }, + }, + } +end) + +Test.gql("Remove config value that exists", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + addConfigValue(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "dont-remove", + value: "keep-this" + } + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + addConfigValue = { + config = { + name = "config-name", + values = { + { + name = "dont-remove", + value = "keep-this", + }, + { + name = "value-name", + value = "new value", + }, + }, + }, + }, + }, + } + + t.query [[ + mutation { + removeConfigValue(input: { + configName: "config-name" + environmentName: "dev" + teamSlug: "myteam" + valueName: "value-name" + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + removeConfigValue = { + config = { + name = "config-name", + values = { + { + name = "dont-remove", + value = "keep-this", + }, + }, + }, + }, + }, + } +end) + +Test.gql("Read config values directly", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + environment(name: "dev") { + config(name: "config-name") { + name + values { + name + value + } + } + } + } + } + ]] + + t.check { + data = { + team = { + environment = { + config = { + name = "config-name", + values = { + { + name = "dont-remove", + value = "keep-this", + }, + }, + }, + }, + }, + }, + } +end) + +Test.gql("Delete config that does not exist", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + deleteConfig(input: { + name: "config-name-that-does-not-exist" + environmentName: "dev" + teamSlug: "myteam" + }) { + configDeleted + } + } + ]] + + t.check { + data = Null, + errors = { + { + message = Contains("Resource not found"), + path = { + "deleteConfig", + }, + }, + }, + } +end) + +Test.gql("Delete config that exists", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + deleteConfig(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + }) { + configDeleted + } + } + ]] + + t.check { + data = { + deleteConfig = { + configDeleted = true, + }, + }, + } +end) + +-- Authorization tests + +Test.gql("Create config as non-team member", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query([[ + mutation { + createConfig(input: { + name: "config-name" + environmentName: "dev" + teamSlug: "myteam" + }) { + config { + name + } + } + } + ]]) + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { + "createConfig", + }, + }, + }, + data = Null, + } +end) + +Test.gql("Update config as non-team member", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query([[ + mutation { + updateConfigValue(input: { + name: "managed-config-in-dev" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "username", + value: "new value" + } + }) { + config { + name + } + } + } + ]]) + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { + "updateConfigValue", + }, + }, + }, + data = Null, + } +end) + +Test.gql("Delete config as non-team member", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query([[ + mutation { + deleteConfig(input: { + name: "managed-config-in-dev" + environmentName: "dev" + teamSlug: "myteam" + }) { + configDeleted + } + } + ]]) + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { + "deleteConfig", + }, + }, + }, + data = Null, + } +end) + +-- Admin tests + +Test.gql("Admin can delete config in other team", function(t) + local adminUser = User.new("admin-delete-test", "admin-delete@example.com", "admin-del") + adminUser:admin(true) + + local teamOwner = User.new("team-owner-del", "owner-del@example.com", "owner-del") + local otherTeam = Team.new("admindeltest", "admin delete test team", "#channel") + otherTeam:addOwner(teamOwner) + + -- Create a config in the team as team owner + t.addHeader("x-user-email", teamOwner:email()) + t.query [[ + mutation { + createConfig(input: { + name: "admin-delete-test" + environmentName: "dev" + teamSlug: "admindeltest" + }) { + config { + name + } + } + } + ]] + + t.check { + data = { + createConfig = { + config = { + name = "admin-delete-test", + }, + }, + }, + } + + -- Admin (not team member) should be able to delete it + t.addHeader("x-user-email", adminUser:email()) + t.query [[ + mutation { + deleteConfig(input: { + name: "admin-delete-test" + environmentName: "dev" + teamSlug: "admindeltest" + }) { + configDeleted + } + } + ]] + + t.check { + data = { + deleteConfig = { + configDeleted = true, + }, + }, + } +end) + +Test.gql("Admin can manage configs in other team", function(t) + local adminUser = User.new("admin-manage-test", "admin-manage@example.com", "admin-mgmt") + adminUser:admin(true) + + local otherTeam = Team.new("adminmgmttest", "admin manage test team", "#channel") + + -- Admin should be able to create config (metadata operation) + t.addHeader("x-user-email", adminUser:email()) + t.query [[ + mutation { + createConfig(input: { + name: "admin-managed-config" + environmentName: "dev" + teamSlug: "adminmgmttest" + }) { + config { + name + } + } + } + ]] + + t.check { + data = { + createConfig = { + config = { + name = "admin-managed-config", + }, + }, + }, + } + + -- Admin should be able to add config value + t.query [[ + mutation { + addConfigValue(input: { + name: "admin-managed-config" + environmentName: "dev" + teamSlug: "adminmgmttest" + value: { + name: "API_URL" + value: "https://example.com" + } + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + addConfigValue = { + config = { + name = "admin-managed-config", + values = { + { + name = "API_URL", + value = "https://example.com", + }, + }, + }, + }, + }, + } +end) + +-- Test listing configs (before activity log test to avoid leaked state) + +Test.gql("List team configs", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + configs { + nodes { + name + } + } + } + } + ]] + + t.check { + data = { + team = { + configs = { + nodes = { + { + name = "managed-config-in-dev", + }, + { + name = "managed-config-in-staging", + }, + { + name = "managed-config-in-staging-used-with-filesfrom", + }, + }, + }, + }, + }, + } +end) + +Test.gql("List configs with values visible", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + environment(name: "dev") { + config(name: "managed-config-in-dev") { + name + values { + name + value + } + } + } + } + } + ]] + + t.check { + data = { + team = { + environment = { + config = { + name = "managed-config-in-dev", + values = { + { + name = "password", + value = "hunter2", + }, + { + name = "username", + value = "admin", + }, + }, + }, + }, + }, + }, + } +end) + +-- Test that unmanaged configs are not visible + +Test.gql("Unmanaged config not in list", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + environment(name: "dev") { + config(name: "unmanaged-config-in-dev") { + name + } + } + } + } + ]] + + t.check { + data = Null, + errors = { + { + message = Contains("not found"), + path = { + "team", + "environment", + "config", + }, + }, + }, + } +end) + +-- Activity log tests + +Test.gql("Config CRUD creates activity log entries", function(t) + t.addHeader("x-user-email", user:email()) + + -- Create a config + t.query [[ + mutation { + createConfig(input: { + name: "activity-log-test" + environmentName: "dev" + teamSlug: "myteam" + }) { + config { name } + } + } + ]] + + t.check { + data = { + createConfig = { + config = { name = "activity-log-test" }, + }, + }, + } + + -- Add a value + t.query [[ + mutation { + addConfigValue(input: { + name: "activity-log-test" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "TEST_KEY", + value: "test-value" + } + }) { + config { name } + } + } + ]] + + t.check { + data = { + addConfigValue = { + config = { name = "activity-log-test" }, + }, + }, + } + + -- Update the value + t.query [[ + mutation { + updateConfigValue(input: { + name: "activity-log-test" + environmentName: "dev" + teamSlug: "myteam" + value: { + name: "TEST_KEY", + value: "updated-value" + } + }) { + config { name } + } + } + ]] + + t.check { + data = { + updateConfigValue = { + config = { name = "activity-log-test" }, + }, + }, + } + + -- Check activity log for config created entry (use first: 1 to get the most recent) + t.query [[ + query { + team(slug: "myteam") { + activityLog(first: 1, filter: { activityTypes: [CONFIG_CREATED] }) { + nodes { + ... on ConfigCreatedActivityLogEntry { + message + resourceName + resourceType + } + } + } + } + } + ]] + + t.check { + data = { + team = { + activityLog = { + nodes = { + { + message = Contains("Created config"), + resourceName = "activity-log-test", + resourceType = "CONFIG", + }, + }, + }, + }, + }, + } + + -- Check activity log for config updated entries (add + update = 2 entries) + t.query [[ + query { + team(slug: "myteam") { + activityLog(first: 2, filter: { activityTypes: [CONFIG_UPDATED] }) { + nodes { + ... on ConfigUpdatedActivityLogEntry { + message + resourceName + data { + updatedFields { + field + oldValue + newValue + } + } + } + } + } + } + } + ]] + + t.check { + data = { + team = { + activityLog = { + nodes = { + { + message = Contains("Updated config"), + resourceName = "activity-log-test", + data = { + updatedFields = { + { + field = "TEST_KEY", + oldValue = "test-value", + newValue = "updated-value", + }, + }, + }, + }, + { + message = Contains("Updated config"), + resourceName = "activity-log-test", + data = { + updatedFields = { + { + field = "TEST_KEY", + oldValue = Null, + newValue = "test-value", + }, + }, + }, + }, + }, + }, + }, + }, + } + + -- Delete the config + t.query [[ + mutation { + deleteConfig(input: { + name: "activity-log-test" + environmentName: "dev" + teamSlug: "myteam" + }) { + configDeleted + } + } + ]] + + t.check { + data = { + deleteConfig = { + configDeleted = true, + }, + }, + } + + -- Check activity log for config deleted entry + t.query [[ + query { + team(slug: "myteam") { + activityLog(first: 1, filter: { activityTypes: [CONFIG_DELETED] }) { + nodes { + ... on ConfigDeletedActivityLogEntry { + message + resourceName + resourceType + } + } + } + } + } + ]] + + t.check { + data = { + team = { + activityLog = { + nodes = { + { + message = Contains("Deleted config"), + resourceName = "activity-log-test", + resourceType = "CONFIG", + }, + }, + }, + }, + }, + } +end) diff --git a/integration_tests/configs_cross_team.lua b/integration_tests/configs_cross_team.lua new file mode 100644 index 000000000..a3fad92a8 --- /dev/null +++ b/integration_tests/configs_cross_team.lua @@ -0,0 +1,389 @@ +-- Test cross-team config access control +-- Verifies that users from other teams: +-- 1. CAN see config names and values (config values are not sensitive) +-- 2. CANNOT create, update, or delete configs + +Helper.readK8sResources("k8s_resources/configs") + +local teamOwner = User.new("team-owner", "owner@example.com", "ext-owner") +local otherUser = User.new("other-user", "other@example.com", "ext-other") + +-- Setup: Create two teams +Test.gql("Create team A (owns configs)", function(t) + t.addHeader("x-user-email", teamOwner:email()) + + t.query [[ + mutation { + createTeam( + input: { + slug: "alpha" + purpose: "Team that owns configs" + slackChannel: "#alpha" + } + ) { + team { + slug + } + } + } + ]] + + t.check { + data = { + createTeam = { + team = { + slug = "alpha", + }, + }, + }, + } +end) + +Test.gql("Create team B (other team)", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + mutation { + createTeam( + input: { + slug: "beta" + purpose: "Other team" + slackChannel: "#beta" + } + ) { + team { + slug + } + } + } + ]] + + t.check { + data = { + createTeam = { + team = { + slug = "beta", + }, + }, + }, + } +end) + +-- Team owner creates a config with values +Test.gql("Team owner creates config with values", function(t) + t.addHeader("x-user-email", teamOwner:email()) + + t.query [[ + mutation { + createConfig(input: { + name: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + }) { + config { + name + } + } + } + ]] + + t.check { + data = { + createConfig = { + config = { + name = "alpha-config", + }, + }, + }, + } + + -- Add some values + t.query [[ + mutation { + addConfigValue(input: { + name: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + value: { + name: "api-url" + value: "https://api.example.com" + } + }) { + config { + name + values { + name + value + } + } + } + } + ]] + + t.check { + data = { + addConfigValue = { + config = { + name = "alpha-config", + values = { + { + name = "api-url", + value = "https://api.example.com", + }, + }, + }, + }, + }, + } +end) + +-- ============================================================ +-- Cross-team READ tests (should be allowed - config values are not sensitive) +-- ============================================================ + +Test.gql("Other team CAN see config names via team.configs", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + query { + team(slug: "alpha") { + configs { + nodes { + name + } + } + } + } + ]] + + t.check { + data = { + team = { + configs = { + nodes = { + { + name = "alpha-config", + }, + }, + }, + }, + }, + } +end) + +Test.gql("Other team CAN see config values", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + query { + team(slug: "alpha") { + environment(name: "dev") { + config(name: "alpha-config") { + name + values { + name + value + } + } + } + } + } + ]] + + t.check { + data = { + team = { + environment = { + config = { + name = "alpha-config", + values = { + { + name = "api-url", + value = "https://api.example.com", + }, + }, + }, + }, + }, + }, + } +end) + +-- ============================================================ +-- Cross-team MUTATION tests (should all be BLOCKED) +-- ============================================================ + +Test.gql("Other team CANNOT create config in alpha", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + mutation { + createConfig(input: { + name: "malicious-config" + environmentName: "dev" + teamSlug: "alpha" + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { "createConfig" }, + }, + }, + data = Null, + } +end) + +Test.gql("Other team CANNOT add value to alpha config", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + mutation { + addConfigValue(input: { + name: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + value: { + name: "malicious-key" + value: "malicious-value" + } + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { "addConfigValue" }, + }, + }, + data = Null, + } +end) + +Test.gql("Other team CANNOT update value in alpha config", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + mutation { + updateConfigValue(input: { + name: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + value: { + name: "api-url" + value: "https://hacked.example.com" + } + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { "updateConfigValue" }, + }, + }, + data = Null, + } +end) + +Test.gql("Other team CANNOT remove value from alpha config", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + mutation { + removeConfigValue(input: { + configName: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + valueName: "api-url" + }) { + config { + name + } + } + } + ]] + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { "removeConfigValue" }, + }, + }, + data = Null, + } +end) + +Test.gql("Other team CANNOT delete alpha config", function(t) + t.addHeader("x-user-email", otherUser:email()) + + t.query [[ + mutation { + deleteConfig(input: { + name: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + }) { + configDeleted + } + } + ]] + + t.check { + errors = { + { + message = Contains("You are authenticated"), + path = { "deleteConfig" }, + }, + }, + data = Null, + } +end) + +-- ============================================================ +-- Verify team owner still has full access +-- ============================================================ + +Test.gql("Team owner CAN delete config (cleanup)", function(t) + t.addHeader("x-user-email", teamOwner:email()) + + t.query [[ + mutation { + deleteConfig(input: { + name: "alpha-config" + environmentName: "dev" + teamSlug: "alpha" + }) { + configDeleted + } + } + ]] + + t.check { + data = { + deleteConfig = { + configDeleted = true, + }, + }, + } +end) diff --git a/integration_tests/k8s_resources/configs/dev/myteam/applications.yaml b/integration_tests/k8s_resources/configs/dev/myteam/applications.yaml new file mode 100644 index 000000000..adc3c8637 --- /dev/null +++ b/integration_tests/k8s_resources/configs/dev/myteam/applications.yaml @@ -0,0 +1,12 @@ +apiVersion: nais.io/v1alpha1 +kind: Application +metadata: + name: app-with-no-configs +--- +apiVersion: nais.io/v1alpha1 +kind: Application +metadata: + name: app-with-configs-via-envfrom +spec: + envFrom: + - configmap: managed-config-in-dev diff --git a/integration_tests/k8s_resources/configs/dev/myteam/configmaps.yaml b/integration_tests/k8s_resources/configs/dev/myteam/configmaps.yaml new file mode 100644 index 000000000..8da380b3e --- /dev/null +++ b/integration_tests/k8s_resources/configs/dev/myteam/configmaps.yaml @@ -0,0 +1,21 @@ +apiVersion: v1 +kind: ConfigMap +metadata: + name: unmanaged-config-in-dev +data: + some-key: some-value +--- +apiVersion: v1 +kind: ConfigMap +metadata: + annotations: + console.nais.io/last-modified-at: "2024-10-18T12:44:57Z" + console.nais.io/last-modified-by: authenticated@example.com + reloader.stakater.com/match: "true" + labels: + nais.io/managed-by: console + app.kubernetes.io/managed-by: console + name: managed-config-in-dev +data: + username: admin + password: hunter2 diff --git a/integration_tests/k8s_resources/configs/staging/myteam/applications.yaml b/integration_tests/k8s_resources/configs/staging/myteam/applications.yaml new file mode 100644 index 000000000..719247b8d --- /dev/null +++ b/integration_tests/k8s_resources/configs/staging/myteam/applications.yaml @@ -0,0 +1,13 @@ +apiVersion: nais.io/v1alpha1 +kind: Application +metadata: + name: app-with-no-configs +spec: +--- +apiVersion: nais.io/v1alpha1 +kind: Application +metadata: + name: app-with-configs-via-filesfrom +spec: + filesFrom: + - configmap: managed-config-in-staging-used-with-filesfrom diff --git a/integration_tests/k8s_resources/configs/staging/myteam/configmaps.yaml b/integration_tests/k8s_resources/configs/staging/myteam/configmaps.yaml new file mode 100644 index 000000000..e25debe77 --- /dev/null +++ b/integration_tests/k8s_resources/configs/staging/myteam/configmaps.yaml @@ -0,0 +1,34 @@ +apiVersion: v1 +kind: ConfigMap +metadata: + name: unmanaged-config-in-staging +data: + foo: bar +--- +apiVersion: v1 +kind: ConfigMap +metadata: + annotations: + console.nais.io/last-modified-at: "2024-10-18T12:44:57Z" + console.nais.io/last-modified-by: authenticated@example.com + reloader.stakater.com/match: "true" + labels: + nais.io/managed-by: console + app.kubernetes.io/managed-by: console + name: managed-config-in-staging +data: + api-url: https://example.com +--- +apiVersion: v1 +kind: ConfigMap +metadata: + annotations: + console.nais.io/last-modified-at: "2024-10-18T12:44:57Z" + console.nais.io/last-modified-by: authenticated@example.com + reloader.stakater.com/match: "true" + labels: + nais.io/managed-by: console + app.kubernetes.io/managed-by: console + name: managed-config-in-staging-used-with-filesfrom +data: + config-file: "{}" diff --git a/integration_tests/workload_configs.lua b/integration_tests/workload_configs.lua new file mode 100644 index 000000000..a55cd78aa --- /dev/null +++ b/integration_tests/workload_configs.lua @@ -0,0 +1,198 @@ +Helper.readK8sResources("k8s_resources/configs") + +local user = User.new("authenticated", "user@user.com", "ext") + +Test.gql("Create team", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + mutation { + createTeam( + input: { + slug: "myteam" + purpose: "some purpose" + slackChannel: "#channel" + } + ) { + team { + slug + } + } + } + ]] + + t.check { + data = { + createTeam = { + team = { + slug = "myteam", + }, + }, + }, + } +end) + +Test.gql("Application with no configs", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + slug + environment(name: "dev") { + application(name: "app-with-no-configs") { + configs { + nodes { + name + } + } + } + } + } + } + ]] + + t.check { + data = { + team = { + slug = "myteam", + environment = { + application = { + configs = { + nodes = {}, + }, + }, + }, + }, + }, + } +end) + +Test.gql("Application with config", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + slug + dev: environment(name: "dev") { + application(name: "app-with-configs-via-envfrom") { + configs { + nodes { + name + } + } + } + } + staging: environment(name: "staging") { + application(name: "app-with-configs-via-filesfrom") { + configs { + nodes { + name + } + } + } + } + } + } + ]] + + t.check { + data = { + team = { + slug = "myteam", + dev = { + application = { + configs = { + nodes = { + { + name = "managed-config-in-dev", + }, + }, + }, + }, + }, + staging = { + application = { + configs = { + nodes = { + { + name = "managed-config-in-staging-used-with-filesfrom", + }, + }, + }, + }, + }, + }, + }, + } +end) + +Test.gql("Configs with workloads", function(t) + t.addHeader("x-user-email", user:email()) + + t.query [[ + { + team(slug: "myteam") { + slug + configs { + nodes { + name + workloads { + nodes { + name + environment { + name + } + } + } + } + } + } + } + ]] + + t.check { + data = { + team = { + slug = "myteam", + configs = { + nodes = { + { + name = "managed-config-in-dev", + workloads = { + nodes = { + { + name = "app-with-configs-via-envfrom", + environment = { + name = "dev", + }, + }, + }, + }, + }, + { + name = "managed-config-in-staging", + workloads = { + nodes = {}, + }, + }, + { + name = "managed-config-in-staging-used-with-filesfrom", + workloads = { + nodes = { + { + name = "app-with-configs-via-filesfrom", + environment = { + name = "staging", + }, + }, + }, + }, + }, + }, + }, + }, + }, + } +end) diff --git a/internal/auth/authz/queries.go b/internal/auth/authz/queries.go index ea4a5a2af..cdfec2cb7 100644 --- a/internal/auth/authz/queries.go +++ b/internal/auth/authz/queries.go @@ -208,6 +208,18 @@ func CanDeleteRepositories(ctx context.Context, teamSlug slug.Slug) error { return requireTeamAuthorization(ctx, teamSlug, "repositories:delete") } +func CanCreateConfigs(ctx context.Context, teamSlug slug.Slug) error { + return requireTeamAuthorization(ctx, teamSlug, "teams:configs:create") +} + +func CanUpdateConfigs(ctx context.Context, teamSlug slug.Slug) error { + return requireTeamAuthorization(ctx, teamSlug, "teams:configs:update") +} + +func CanDeleteConfigs(ctx context.Context, teamSlug slug.Slug) error { + return requireTeamAuthorization(ctx, teamSlug, "teams:configs:delete") +} + func CanCreateSecrets(ctx context.Context, teamSlug slug.Slug) error { return requireTeamAuthorization(ctx, teamSlug, "teams:secrets:create") } diff --git a/internal/cmd/api/http.go b/internal/cmd/api/http.go index d0030c281..dde159190 100644 --- a/internal/cmd/api/http.go +++ b/internal/cmd/api/http.go @@ -57,6 +57,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/logging" "github.com/nais/api/internal/workload/podlog" @@ -314,6 +315,7 @@ func ConfigureGraph( ctx = kafkatopic.NewLoaderContext(ctx, watchers.KafkaTopicWatcher) ctx = workload.NewLoaderContext(ctx, watchers.PodWatcher) ctx = secret.NewLoaderContext(ctx, watchers.SecretWatcher, secretClientCreator, dynamicClients, clusters, log) + ctx = configmap.NewLoaderContext(ctx, watchers.ConfigMapWatcher, log) ctx = aiven.NewLoaderContext(ctx, aivenProjects) ctx = opensearch.NewLoaderContext(ctx, tenantName, watchers.OpenSearchWatcher, aivenClient, log) ctx = valkey.NewLoaderContext(ctx, tenantName, watchers.ValkeyWatcher, aivenClient) diff --git a/internal/database/migrations/0060_add_config_authorizations.sql b/internal/database/migrations/0060_add_config_authorizations.sql new file mode 100644 index 000000000..7a055ab7b --- /dev/null +++ b/internal/database/migrations/0060_add_config_authorizations.sql @@ -0,0 +1,36 @@ +-- +goose Up +-- Create new authorizations for managing configs (ConfigMaps) +INSERT INTO + authorizations (name, description) +VALUES + ( + 'teams:configs:create', + 'Permission to create configs for a team.' + ), + ( + 'teams:configs:update', + 'Permission to update configs for a team.' + ), + ( + 'teams:configs:delete', + 'Permission to delete configs for a team.' + ) +; + +-- Grant these authorizations to Team member role +INSERT INTO + role_authorizations (role_name, authorization_name) +VALUES + ('Team member', 'teams:configs:create'), + ('Team member', 'teams:configs:update'), + ('Team member', 'teams:configs:delete') +; + +-- Grant these authorizations to Team owner role +INSERT INTO + role_authorizations (role_name, authorization_name) +VALUES + ('Team owner', 'teams:configs:create'), + ('Team owner', 'teams:configs:update'), + ('Team owner', 'teams:configs:delete') +; diff --git a/internal/graph/configmap.resolvers.go b/internal/graph/configmap.resolvers.go new file mode 100644 index 000000000..bd0e3e1c0 --- /dev/null +++ b/internal/graph/configmap.resolvers.go @@ -0,0 +1,249 @@ +package graph + +import ( + "context" + "errors" + "slices" + + "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/auth/authz" + "github.com/nais/api/internal/environmentmapper" + "github.com/nais/api/internal/graph/gengql" + "github.com/nais/api/internal/graph/model" + "github.com/nais/api/internal/graph/pagination" + "github.com/nais/api/internal/team" + "github.com/nais/api/internal/user" + "github.com/nais/api/internal/workload" + "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" + "github.com/nais/api/internal/workload/job" +) + +func (r *applicationResolver) Configs(ctx context.Context, obj *application.Application, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*configmap.Config], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + return configmap.ListForWorkload(ctx, obj.TeamSlug, obj.EnvironmentName, obj, page) +} + +func (r *configResolver) TeamEnvironment(ctx context.Context, obj *configmap.Config) (*team.TeamEnvironment, error) { + return team.GetTeamEnvironment(ctx, obj.TeamSlug, obj.EnvironmentName) +} + +func (r *configResolver) Team(ctx context.Context, obj *configmap.Config) (*team.Team, error) { + return team.Get(ctx, obj.TeamSlug) +} + +func (r *configResolver) Values(ctx context.Context, obj *configmap.Config) ([]*configmap.ConfigValue, error) { + return configmap.GetConfigValues(ctx, obj.TeamSlug, obj.EnvironmentName, obj.Name) +} + +func (r *configResolver) Applications(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*application.Application], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + allApps := application.ListAllForTeamInEnvironment(ctx, obj.TeamSlug, obj.EnvironmentName) + + ret := make([]*application.Application, 0) + for _, app := range allApps { + if slices.Contains(app.GetConfigs(), obj.Name) { + ret = append(ret, app) + } + } + + apps := pagination.Slice(ret, page) + return pagination.NewConnection(apps, page, len(ret)), nil +} + +func (r *configResolver) Jobs(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*job.Job], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + allJobs := job.ListAllForTeamInEnvironment(ctx, obj.TeamSlug, obj.EnvironmentName) + + ret := make([]*job.Job, 0) + for _, j := range allJobs { + if slices.Contains(j.GetConfigs(), obj.Name) { + ret = append(ret, j) + } + } + + jobs := pagination.Slice(ret, page) + return pagination.NewConnection(jobs, page, len(ret)), nil +} + +func (r *configResolver) Workloads(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[workload.Workload], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + ret := make([]workload.Workload, 0) + + applications := application.ListAllForTeamInEnvironment(ctx, obj.TeamSlug, obj.EnvironmentName) + for _, app := range applications { + if slices.Contains(app.GetConfigs(), obj.Name) { + ret = append(ret, app) + } + } + + jobs := job.ListAllForTeamInEnvironment(ctx, obj.TeamSlug, obj.EnvironmentName) + for _, j := range jobs { + if slices.Contains(j.GetConfigs(), obj.Name) { + ret = append(ret, j) + } + } + + slices.SortStableFunc(ret, func(a, b workload.Workload) int { + return model.Compare(a.GetName(), b.GetName(), model.OrderDirectionAsc) + }) + workloads := pagination.Slice(ret, page) + return pagination.NewConnection(workloads, page, len(ret)), nil +} + +func (r *configResolver) LastModifiedBy(ctx context.Context, obj *configmap.Config) (*user.User, error) { + if obj.ModifiedByUserEmail == nil { + return nil, nil + } + + u, err := user.GetByEmail(ctx, *obj.ModifiedByUserEmail) + if err != nil { + var notFound user.ErrNotFound + if errors.As(err, ¬Found) { + return nil, nil + } + return nil, err + } + return u, nil +} + +func (r *configResolver) ActivityLog(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) (*pagination.Connection[activitylog.ActivityLogEntry], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + return activitylog.ListForResourceTeamAndEnvironment( + ctx, + "CONFIG", + obj.TeamSlug, + obj.Name, + environmentmapper.EnvironmentName(obj.EnvironmentName), + page, + filter, + ) +} + +func (r *jobResolver) Configs(ctx context.Context, obj *job.Job, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*configmap.Config], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + return configmap.ListForWorkload(ctx, obj.TeamSlug, obj.EnvironmentName, obj, page) +} + +func (r *mutationResolver) CreateConfig(ctx context.Context, input configmap.CreateConfigInput) (*configmap.CreateConfigPayload, error) { + if err := authz.CanCreateConfigs(ctx, input.TeamSlug); err != nil { + return nil, err + } + + c, err := configmap.Create(ctx, input.TeamSlug, input.EnvironmentName, input.Name) + if err != nil { + return nil, err + } + + return &configmap.CreateConfigPayload{ + Config: c, + }, nil +} + +func (r *mutationResolver) AddConfigValue(ctx context.Context, input configmap.AddConfigValueInput) (*configmap.AddConfigValuePayload, error) { + if err := authz.CanUpdateConfigs(ctx, input.TeamSlug); err != nil { + return nil, err + } + + c, err := configmap.AddConfigValue(ctx, input.TeamSlug, input.EnvironmentName, input.Name, input.Value) + if err != nil { + return nil, err + } + + return &configmap.AddConfigValuePayload{ + Config: c, + }, nil +} + +func (r *mutationResolver) UpdateConfigValue(ctx context.Context, input configmap.UpdateConfigValueInput) (*configmap.UpdateConfigValuePayload, error) { + if err := authz.CanUpdateConfigs(ctx, input.TeamSlug); err != nil { + return nil, err + } + + c, err := configmap.UpdateConfigValue(ctx, input.TeamSlug, input.EnvironmentName, input.Name, input.Value) + if err != nil { + return nil, err + } + + return &configmap.UpdateConfigValuePayload{ + Config: c, + }, nil +} + +func (r *mutationResolver) RemoveConfigValue(ctx context.Context, input configmap.RemoveConfigValueInput) (*configmap.RemoveConfigValuePayload, error) { + if err := authz.CanUpdateConfigs(ctx, input.TeamSlug); err != nil { + return nil, err + } + + c, err := configmap.RemoveConfigValue(ctx, input.TeamSlug, input.EnvironmentName, input.ConfigName, input.ValueName) + if err != nil { + return nil, err + } + + return &configmap.RemoveConfigValuePayload{ + Config: c, + }, nil +} + +func (r *mutationResolver) DeleteConfig(ctx context.Context, input configmap.DeleteConfigInput) (*configmap.DeleteConfigPayload, error) { + if err := authz.CanDeleteConfigs(ctx, input.TeamSlug); err != nil { + return nil, err + } + + if err := configmap.Delete(ctx, input.TeamSlug, input.EnvironmentName, input.Name); err != nil { + return nil, err + } + + return &configmap.DeleteConfigPayload{ + ConfigDeleted: true, + }, nil +} + +// Configs returns all configs for a team. +func (r *teamResolver) Configs(ctx context.Context, obj *team.Team, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *configmap.ConfigOrder, filter *configmap.ConfigFilter) (*pagination.Connection[*configmap.Config], error) { + page, err := pagination.ParsePage(first, after, last, before) + if err != nil { + return nil, err + } + + return configmap.ListForTeam(ctx, obj.Slug, page, orderBy, filter) +} + +// Config returns a single config by name. +func (r *teamEnvironmentResolver) Config(ctx context.Context, obj *team.TeamEnvironment, name string) (*configmap.Config, error) { + return configmap.Get(ctx, obj.TeamSlug, obj.EnvironmentName, name) +} + +func (r *teamInventoryCountsResolver) Configs(ctx context.Context, obj *team.TeamInventoryCounts) (*configmap.TeamInventoryCountConfigs, error) { + return &configmap.TeamInventoryCountConfigs{ + Total: configmap.CountForTeam(ctx, obj.TeamSlug), + }, nil +} + +func (r *Resolver) Config() gengql.ConfigResolver { return &configResolver{r} } + +type configResolver struct{ *Resolver } diff --git a/internal/graph/gengql/activitylog.generated.go b/internal/graph/gengql/activitylog.generated.go index a9bfb3ae1..38a954630 100644 --- a/internal/graph/gengql/activitylog.generated.go +++ b/internal/graph/gengql/activitylog.generated.go @@ -27,6 +27,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/secret" "github.com/vektah/gqlparser/v2/ast" @@ -559,6 +560,27 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._CredentialsActivityLogEntry(ctx, sel, obj) + case configmap.ConfigUpdatedActivityLogEntry: + return ec._ConfigUpdatedActivityLogEntry(ctx, sel, &obj) + case *configmap.ConfigUpdatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ConfigUpdatedActivityLogEntry(ctx, sel, obj) + case configmap.ConfigDeletedActivityLogEntry: + return ec._ConfigDeletedActivityLogEntry(ctx, sel, &obj) + case *configmap.ConfigDeletedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ConfigDeletedActivityLogEntry(ctx, sel, obj) + case configmap.ConfigCreatedActivityLogEntry: + return ec._ConfigCreatedActivityLogEntry(ctx, sel, &obj) + case *configmap.ConfigCreatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ConfigCreatedActivityLogEntry(ctx, sel, obj) case pubsublog.ClusterAuditActivityLogEntry: return ec._ClusterAuditActivityLogEntry(ctx, sel, &obj) case *pubsublog.ClusterAuditActivityLogEntry: @@ -661,6 +683,13 @@ func (ec *executionContext) _ActivityLogger(ctx context.Context, sel ast.Selecti return graphql.Null } return ec._ContainerImage(ctx, sel, obj) + case configmap.Config: + return ec._Config(ctx, sel, &obj) + case *configmap.Config: + if obj == nil { + return graphql.Null + } + return ec._Config(ctx, sel, obj) default: if typedObj, ok := obj.(graphql.Marshaler); ok { return typedObj diff --git a/internal/graph/gengql/alerts.generated.go b/internal/graph/gengql/alerts.generated.go index b54e97add..6b05e6e44 100644 --- a/internal/graph/gengql/alerts.generated.go +++ b/internal/graph/gengql/alerts.generated.go @@ -498,6 +498,8 @@ func (ec *executionContext) fieldContext_PrometheusAlert_team(_ context.Context, return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -587,6 +589,8 @@ func (ec *executionContext) fieldContext_PrometheusAlert_teamEnvironment(_ conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/applications.generated.go b/internal/graph/gengql/applications.generated.go index 2bdc76102..11ccc7840 100644 --- a/internal/graph/gengql/applications.generated.go +++ b/internal/graph/gengql/applications.generated.go @@ -28,6 +28,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/logging" "github.com/nais/api/internal/workload/netpol" "github.com/nais/api/internal/workload/secret" @@ -50,6 +51,7 @@ type ApplicationResolver interface { Issues(ctx context.Context, obj *application.Application, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *issue.IssueOrder, filter *issue.ResourceIssueFilter) (*pagination.Connection[issue.Issue], error) BigQueryDatasets(ctx context.Context, obj *application.Application, orderBy *bigquery.BigQueryDatasetOrder) (*pagination.Connection[*bigquery.BigQueryDataset], error) Buckets(ctx context.Context, obj *application.Application, orderBy *bucket.BucketOrder) (*pagination.Connection[*bucket.Bucket], error) + Configs(ctx context.Context, obj *application.Application, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*configmap.Config], error) Cost(ctx context.Context, obj *application.Application) (*cost.WorkloadCost, error) Deployments(ctx context.Context, obj *application.Application, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*deployment.Deployment], error) KafkaTopicAcls(ctx context.Context, obj *application.Application, orderBy *kafkatopic.KafkaTopicACLOrder) (*pagination.Connection[*kafkatopic.KafkaTopicACL], error) @@ -151,6 +153,32 @@ func (ec *executionContext) field_Application_buckets_args(ctx context.Context, return args, nil } +func (ec *executionContext) field_Application_configs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + return args, nil +} + func (ec *executionContext) field_Application_deployments_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -472,6 +500,8 @@ func (ec *executionContext) fieldContext_Application_team(_ context.Context, fie return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -561,6 +591,8 @@ func (ec *executionContext) fieldContext_Application_environment(_ context.Conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -630,6 +662,8 @@ func (ec *executionContext) fieldContext_Application_teamEnvironment(_ context.C return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1143,6 +1177,55 @@ func (ec *executionContext) fieldContext_Application_buckets(ctx context.Context return fc, nil } +func (ec *executionContext) _Application_configs(ctx context.Context, field graphql.CollectedField, obj *application.Application) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Application_configs, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Application().Configs(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor)) + }, + nil, + ec.marshalNConfigConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Application_configs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Application", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_ConfigConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_ConfigConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_ConfigConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Application_configs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Application_cost(ctx context.Context, field graphql.CollectedField, obj *application.Application) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -1839,6 +1922,8 @@ func (ec *executionContext) fieldContext_ApplicationConnection_nodes(_ context.C return ec.fieldContext_Application_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Application_buckets(ctx, field) + case "configs": + return ec.fieldContext_Application_configs(ctx, field) case "cost": return ec.fieldContext_Application_cost(ctx, field) case "deployments": @@ -2226,6 +2311,8 @@ func (ec *executionContext) fieldContext_ApplicationEdge_node(_ context.Context, return ec.fieldContext_Application_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Application_buckets(ctx, field) + case "configs": + return ec.fieldContext_Application_configs(ctx, field) case "cost": return ec.fieldContext_Application_cost(ctx, field) case "deployments": @@ -3632,6 +3719,8 @@ func (ec *executionContext) fieldContext_DeleteApplicationPayload_team(_ context return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -4111,6 +4200,8 @@ func (ec *executionContext) fieldContext_RestartApplicationPayload_application(_ return ec.fieldContext_Application_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Application_buckets(ctx, field) + case "configs": + return ec.fieldContext_Application_configs(ctx, field) case "cost": return ec.fieldContext_Application_cost(ctx, field) case "deployments": @@ -4872,6 +4963,42 @@ func (ec *executionContext) _Application(ctx context.Context, sel ast.SelectionS continue } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "configs": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Application_configs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) case "cost": field := field diff --git a/internal/graph/gengql/bigquery.generated.go b/internal/graph/gengql/bigquery.generated.go index 9d8ad79b8..006e81468 100644 --- a/internal/graph/gengql/bigquery.generated.go +++ b/internal/graph/gengql/bigquery.generated.go @@ -196,6 +196,8 @@ func (ec *executionContext) fieldContext_BigQueryDataset_team(_ context.Context, return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -285,6 +287,8 @@ func (ec *executionContext) fieldContext_BigQueryDataset_environment(_ context.C return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -354,6 +358,8 @@ func (ec *executionContext) fieldContext_BigQueryDataset_teamEnvironment(_ conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/bucket.generated.go b/internal/graph/gengql/bucket.generated.go index 2c6b5e661..857ee6d31 100644 --- a/internal/graph/gengql/bucket.generated.go +++ b/internal/graph/gengql/bucket.generated.go @@ -161,6 +161,8 @@ func (ec *executionContext) fieldContext_Bucket_team(_ context.Context, field gr return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -250,6 +252,8 @@ func (ec *executionContext) fieldContext_Bucket_environment(_ context.Context, f return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -319,6 +323,8 @@ func (ec *executionContext) fieldContext_Bucket_teamEnvironment(_ context.Contex return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/complexity.go b/internal/graph/gengql/complexity.go index 4459f32d9..bf93e55e7 100644 --- a/internal/graph/gengql/complexity.go +++ b/internal/graph/gengql/complexity.go @@ -22,6 +22,7 @@ import ( vulnerability "github.com/nais/api/internal/vulnerability" workload "github.com/nais/api/internal/workload" application "github.com/nais/api/internal/workload/application" + configmap "github.com/nais/api/internal/workload/configmap" job "github.com/nais/api/internal/workload/job" secret "github.com/nais/api/internal/workload/secret" ) @@ -32,6 +33,9 @@ func NewComplexityRoot() ComplexityRoot { c.Application.ActivityLog = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int { return cursorComplexity(first, last) * childComplexity } + c.Application.Configs = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { + return cursorComplexity(first, last) * childComplexity + } c.Application.Deployments = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { return cursorComplexity(first, last) * childComplexity } @@ -50,6 +54,18 @@ func NewComplexityRoot() ComplexityRoot { c.CVE.Workloads = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { return cursorComplexity(first, last) * childComplexity } + c.Config.ActivityLog = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int { + return cursorComplexity(first, last) * childComplexity + } + c.Config.Applications = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { + return cursorComplexity(first, last) * childComplexity + } + c.Config.Jobs = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { + return cursorComplexity(first, last) * childComplexity + } + c.Config.Workloads = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { + return cursorComplexity(first, last) * childComplexity + } c.ContainerImage.ActivityLog = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int { return cursorComplexity(first, last) * childComplexity } @@ -71,6 +87,9 @@ func NewComplexityRoot() ComplexityRoot { c.Job.ActivityLog = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int { return cursorComplexity(first, last) * childComplexity } + c.Job.Configs = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { + return cursorComplexity(first, last) * childComplexity + } c.Job.Deployments = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { return cursorComplexity(first, last) * childComplexity } @@ -179,6 +198,9 @@ func NewComplexityRoot() ComplexityRoot { c.Team.Buckets = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bucket.BucketOrder) int { return cursorComplexity(first, last) * childComplexity } + c.Team.Configs = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *configmap.ConfigOrder, filter *configmap.ConfigFilter) int { + return cursorComplexity(first, last) * childComplexity + } c.Team.Deployments = func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int { return cursorComplexity(first, last) * childComplexity } diff --git a/internal/graph/gengql/configmap.generated.go b/internal/graph/gengql/configmap.generated.go new file mode 100644 index 000000000..bcff84ad8 --- /dev/null +++ b/internal/graph/gengql/configmap.generated.go @@ -0,0 +1,3696 @@ +// Code generated by github.com/99designs/gqlgen, DO NOT EDIT. + +package gengql + +import ( + "context" + "errors" + "fmt" + "strconv" + "sync/atomic" + + "github.com/99designs/gqlgen/graphql" + "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/graph/pagination" + "github.com/nais/api/internal/team" + "github.com/nais/api/internal/user" + "github.com/nais/api/internal/workload" + "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" + "github.com/nais/api/internal/workload/job" + "github.com/vektah/gqlparser/v2/ast" +) + +// region ************************** generated!.gotpl ************************** + +type ConfigResolver interface { + TeamEnvironment(ctx context.Context, obj *configmap.Config) (*team.TeamEnvironment, error) + Team(ctx context.Context, obj *configmap.Config) (*team.Team, error) + Values(ctx context.Context, obj *configmap.Config) ([]*configmap.ConfigValue, error) + Applications(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*application.Application], error) + Jobs(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*job.Job], error) + Workloads(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[workload.Workload], error) + + LastModifiedBy(ctx context.Context, obj *configmap.Config) (*user.User, error) + ActivityLog(ctx context.Context, obj *configmap.Config, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) (*pagination.Connection[activitylog.ActivityLogEntry], error) +} + +// endregion ************************** generated!.gotpl ************************** + +// region ***************************** args.gotpl ***************************** + +func (ec *executionContext) field_Config_activityLog_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + arg4, err := graphql.ProcessArgField(ctx, rawArgs, "filter", ec.unmarshalOActivityLogFilter2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogFilter) + if err != nil { + return nil, err + } + args["filter"] = arg4 + return args, nil +} + +func (ec *executionContext) field_Config_applications_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + return args, nil +} + +func (ec *executionContext) field_Config_jobs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + return args, nil +} + +func (ec *executionContext) field_Config_workloads_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + return args, nil +} + +// endregion ***************************** args.gotpl ***************************** + +// region ************************** directives.gotpl ************************** + +// endregion ************************** directives.gotpl ************************** + +// region **************************** field.gotpl ***************************** + +func (ec *executionContext) _AddConfigValuePayload_config(ctx context.Context, field graphql.CollectedField, obj *configmap.AddConfigValuePayload) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_AddConfigValuePayload_config, + func(ctx context.Context) (any, error) { + return obj.Config, nil + }, + nil, + ec.marshalOConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_AddConfigValuePayload_config(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "AddConfigValuePayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_id(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_name(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_name, + func(ctx context.Context) (any, error) { + return obj.Name, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_teamEnvironment(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_teamEnvironment, + func(ctx context.Context) (any, error) { + return ec.Resolvers.Config().TeamEnvironment(ctx, obj) + }, + nil, + ec.marshalNTeamEnvironment2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋteamᚐTeamEnvironment, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_teamEnvironment(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_TeamEnvironment_id(ctx, field) + case "name": + return ec.fieldContext_TeamEnvironment_name(ctx, field) + case "gcpProjectID": + return ec.fieldContext_TeamEnvironment_gcpProjectID(ctx, field) + case "slackAlertsChannel": + return ec.fieldContext_TeamEnvironment_slackAlertsChannel(ctx, field) + case "team": + return ec.fieldContext_TeamEnvironment_team(ctx, field) + case "alerts": + return ec.fieldContext_TeamEnvironment_alerts(ctx, field) + case "application": + return ec.fieldContext_TeamEnvironment_application(ctx, field) + case "bigQueryDataset": + return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) + case "bucket": + return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) + case "cost": + return ec.fieldContext_TeamEnvironment_cost(ctx, field) + case "environment": + return ec.fieldContext_TeamEnvironment_environment(ctx, field) + case "job": + return ec.fieldContext_TeamEnvironment_job(ctx, field) + case "kafkaTopic": + return ec.fieldContext_TeamEnvironment_kafkaTopic(ctx, field) + case "openSearch": + return ec.fieldContext_TeamEnvironment_openSearch(ctx, field) + case "postgresInstance": + return ec.fieldContext_TeamEnvironment_postgresInstance(ctx, field) + case "secret": + return ec.fieldContext_TeamEnvironment_secret(ctx, field) + case "sqlInstance": + return ec.fieldContext_TeamEnvironment_sqlInstance(ctx, field) + case "valkey": + return ec.fieldContext_TeamEnvironment_valkey(ctx, field) + case "workload": + return ec.fieldContext_TeamEnvironment_workload(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type TeamEnvironment", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_team(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_team, + func(ctx context.Context) (any, error) { + return ec.Resolvers.Config().Team(ctx, obj) + }, + nil, + ec.marshalNTeam2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋteamᚐTeam, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_team(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Team_id(ctx, field) + case "slug": + return ec.fieldContext_Team_slug(ctx, field) + case "slackChannel": + return ec.fieldContext_Team_slackChannel(ctx, field) + case "purpose": + return ec.fieldContext_Team_purpose(ctx, field) + case "externalResources": + return ec.fieldContext_Team_externalResources(ctx, field) + case "member": + return ec.fieldContext_Team_member(ctx, field) + case "members": + return ec.fieldContext_Team_members(ctx, field) + case "lastSuccessfulSync": + return ec.fieldContext_Team_lastSuccessfulSync(ctx, field) + case "deletionInProgress": + return ec.fieldContext_Team_deletionInProgress(ctx, field) + case "viewerIsOwner": + return ec.fieldContext_Team_viewerIsOwner(ctx, field) + case "viewerIsMember": + return ec.fieldContext_Team_viewerIsMember(ctx, field) + case "environments": + return ec.fieldContext_Team_environments(ctx, field) + case "environment": + return ec.fieldContext_Team_environment(ctx, field) + case "deleteKey": + return ec.fieldContext_Team_deleteKey(ctx, field) + case "inventoryCounts": + return ec.fieldContext_Team_inventoryCounts(ctx, field) + case "activityLog": + return ec.fieldContext_Team_activityLog(ctx, field) + case "alerts": + return ec.fieldContext_Team_alerts(ctx, field) + case "applications": + return ec.fieldContext_Team_applications(ctx, field) + case "bigQueryDatasets": + return ec.fieldContext_Team_bigQueryDatasets(ctx, field) + case "buckets": + return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) + case "cost": + return ec.fieldContext_Team_cost(ctx, field) + case "deploymentKey": + return ec.fieldContext_Team_deploymentKey(ctx, field) + case "deployments": + return ec.fieldContext_Team_deployments(ctx, field) + case "issues": + return ec.fieldContext_Team_issues(ctx, field) + case "jobs": + return ec.fieldContext_Team_jobs(ctx, field) + case "kafkaTopics": + return ec.fieldContext_Team_kafkaTopics(ctx, field) + case "openSearches": + return ec.fieldContext_Team_openSearches(ctx, field) + case "postgresInstances": + return ec.fieldContext_Team_postgresInstances(ctx, field) + case "repositories": + return ec.fieldContext_Team_repositories(ctx, field) + case "secrets": + return ec.fieldContext_Team_secrets(ctx, field) + case "sqlInstances": + return ec.fieldContext_Team_sqlInstances(ctx, field) + case "unleash": + return ec.fieldContext_Team_unleash(ctx, field) + case "workloadUtilization": + return ec.fieldContext_Team_workloadUtilization(ctx, field) + case "serviceUtilization": + return ec.fieldContext_Team_serviceUtilization(ctx, field) + case "valkeys": + return ec.fieldContext_Team_valkeys(ctx, field) + case "imageVulnerabilityHistory": + return ec.fieldContext_Team_imageVulnerabilityHistory(ctx, field) + case "vulnerabilityFixHistory": + return ec.fieldContext_Team_vulnerabilityFixHistory(ctx, field) + case "vulnerabilitySummary": + return ec.fieldContext_Team_vulnerabilitySummary(ctx, field) + case "vulnerabilitySummaries": + return ec.fieldContext_Team_vulnerabilitySummaries(ctx, field) + case "workloads": + return ec.fieldContext_Team_workloads(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Team", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_values(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_values, + func(ctx context.Context) (any, error) { + return ec.Resolvers.Config().Values(ctx, obj) + }, + nil, + ec.marshalNConfigValue2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValueᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_values(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext_ConfigValue_name(ctx, field) + case "value": + return ec.fieldContext_ConfigValue_value(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigValue", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_applications(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_applications, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Config().Applications(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor)) + }, + nil, + ec.marshalNApplicationConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_applications(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_ApplicationConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_ApplicationConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_ApplicationConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplicationConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Config_applications_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Config_jobs(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_jobs, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Config().Jobs(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor)) + }, + nil, + ec.marshalNJobConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_jobs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_JobConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_JobConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_JobConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type JobConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Config_jobs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Config_workloads(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_workloads, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Config().Workloads(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor)) + }, + nil, + ec.marshalNWorkloadConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_workloads(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_WorkloadConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_WorkloadConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_WorkloadConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type WorkloadConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Config_workloads_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Config_lastModifiedAt(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_lastModifiedAt, + func(ctx context.Context) (any, error) { + return obj.LastModifiedAt, nil + }, + nil, + ec.marshalOTime2ᚖtimeᚐTime, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_Config_lastModifiedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_lastModifiedBy(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_lastModifiedBy, + func(ctx context.Context) (any, error) { + return ec.Resolvers.Config().LastModifiedBy(ctx, obj) + }, + nil, + ec.marshalOUser2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋuserᚐUser, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_Config_lastModifiedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_User_id(ctx, field) + case "email": + return ec.fieldContext_User_email(ctx, field) + case "name": + return ec.fieldContext_User_name(ctx, field) + case "externalID": + return ec.fieldContext_User_externalID(ctx, field) + case "teams": + return ec.fieldContext_User_teams(ctx, field) + case "isAdmin": + return ec.fieldContext_User_isAdmin(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type User", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Config_activityLog(ctx context.Context, field graphql.CollectedField, obj *configmap.Config) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Config_activityLog, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Config().ActivityLog(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor), fc.Args["filter"].(*activitylog.ActivityLogFilter)) + }, + nil, + ec.marshalNActivityLogEntryConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Config_activityLog(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Config", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_ActivityLogEntryConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_ActivityLogEntryConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_ActivityLogEntryConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ActivityLogEntryConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Config_activityLog_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _ConfigConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *pagination.Connection[*configmap.Config]) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigConnection_pageInfo, + func(ctx context.Context) (any, error) { + return obj.PageInfo, nil + }, + nil, + ec.marshalNPageInfo2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐPageInfo, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigConnection", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "totalCount": + return ec.fieldContext_PageInfo_totalCount(ctx, field) + case "pageStart": + return ec.fieldContext_PageInfo_pageStart(ctx, field) + case "pageEnd": + return ec.fieldContext_PageInfo_pageEnd(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *pagination.Connection[*configmap.Config]) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigConnection_nodes, + func(ctx context.Context) (any, error) { + return obj.Nodes(), nil + }, + nil, + ec.marshalNConfig2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigConnection", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigConnection_edges(ctx context.Context, field graphql.CollectedField, obj *pagination.Connection[*configmap.Config]) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigConnection_edges, + func(ctx context.Context) (any, error) { + return obj.Edges, nil + }, + nil, + ec.marshalNConfigEdge2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐEdgeᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigConnection", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "cursor": + return ec.fieldContext_ConfigEdge_cursor(ctx, field) + case "node": + return ec.fieldContext_ConfigEdge_node(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigEdge", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigCreatedActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ConfigCreatedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigDeletedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigDeletedActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ConfigDeletedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigDeletedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *pagination.Edge[*configmap.Config]) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigEdge_cursor, + func(ctx context.Context) (any, error) { + return obj.Cursor, nil + }, + nil, + ec.marshalNCursor2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigEdge", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Cursor does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigEdge_node(ctx context.Context, field graphql.CollectedField, obj *pagination.Edge[*configmap.Config]) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigEdge_node, + func(ctx context.Context) (any, error) { + return obj.Node, nil + }, + nil, + ec.marshalNConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigEdge", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNConfigUpdatedActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigUpdatedActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "updatedFields": + return ec.fieldContext_ConfigUpdatedActivityLogEntryData_updatedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigUpdatedActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntryData_updatedFields(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntryData_updatedFields, + func(ctx context.Context) (any, error) { + return obj.UpdatedFields, nil + }, + nil, + ec.marshalNConfigUpdatedActivityLogEntryDataUpdatedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigUpdatedActivityLogEntryDataUpdatedFieldᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntryData_updatedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntryData", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "field": + return ec.fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_field(ctx, field) + case "oldValue": + return ec.fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_oldValue(ctx, field) + case "newValue": + return ec.fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_newValue(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigUpdatedActivityLogEntryDataUpdatedField", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntryDataUpdatedField_field(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntryDataUpdatedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_field, + func(ctx context.Context) (any, error) { + return obj.Field, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_field(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntryDataUpdatedField", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntryDataUpdatedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntryDataUpdatedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_oldValue, + func(ctx context.Context) (any, error) { + return obj.OldValue, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_oldValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntryDataUpdatedField", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntryDataUpdatedField_newValue(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigUpdatedActivityLogEntryDataUpdatedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_newValue, + func(ctx context.Context) (any, error) { + return obj.NewValue, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ConfigUpdatedActivityLogEntryDataUpdatedField_newValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigUpdatedActivityLogEntryDataUpdatedField", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigValue_name(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigValue_name, + func(ctx context.Context) (any, error) { + return obj.Name, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigValue", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigValue_value(ctx context.Context, field graphql.CollectedField, obj *configmap.ConfigValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ConfigValue_value, + func(ctx context.Context) (any, error) { + return obj.Value, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ConfigValue_value(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigValue", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _CreateConfigPayload_config(ctx context.Context, field graphql.CollectedField, obj *configmap.CreateConfigPayload) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_CreateConfigPayload_config, + func(ctx context.Context) (any, error) { + return obj.Config, nil + }, + nil, + ec.marshalOConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_CreateConfigPayload_config(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "CreateConfigPayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _DeleteConfigPayload_configDeleted(ctx context.Context, field graphql.CollectedField, obj *configmap.DeleteConfigPayload) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_DeleteConfigPayload_configDeleted, + func(ctx context.Context) (any, error) { + return obj.ConfigDeleted, nil + }, + nil, + ec.marshalOBoolean2bool, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_DeleteConfigPayload_configDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DeleteConfigPayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _RemoveConfigValuePayload_config(ctx context.Context, field graphql.CollectedField, obj *configmap.RemoveConfigValuePayload) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_RemoveConfigValuePayload_config, + func(ctx context.Context) (any, error) { + return obj.Config, nil + }, + nil, + ec.marshalOConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_RemoveConfigValuePayload_config(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "RemoveConfigValuePayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _TeamInventoryCountConfigs_total(ctx context.Context, field graphql.CollectedField, obj *configmap.TeamInventoryCountConfigs) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_TeamInventoryCountConfigs_total, + func(ctx context.Context) (any, error) { + return obj.Total, nil + }, + nil, + ec.marshalNInt2int, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_TeamInventoryCountConfigs_total(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "TeamInventoryCountConfigs", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _UpdateConfigValuePayload_config(ctx context.Context, field graphql.CollectedField, obj *configmap.UpdateConfigValuePayload) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UpdateConfigValuePayload_config, + func(ctx context.Context) (any, error) { + return obj.Config, nil + }, + nil, + ec.marshalOConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_UpdateConfigValuePayload_config(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UpdateConfigValuePayload", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + return fc, nil +} + +// endregion **************************** field.gotpl ***************************** + +// region **************************** input.gotpl ***************************** + +func (ec *executionContext) unmarshalInputAddConfigValueInput(ctx context.Context, obj any) (configmap.AddConfigValueInput, error) { + var it configmap.AddConfigValueInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "environmentName", "teamSlug", "value"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "environmentName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("environmentName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.EnvironmentName = data + case "teamSlug": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("teamSlug")) + data, err := ec.unmarshalNSlug2githubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug(ctx, v) + if err != nil { + return it, err + } + it.TeamSlug = data + case "value": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value")) + data, err := ec.unmarshalNConfigValueInput2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValueInput(ctx, v) + if err != nil { + return it, err + } + it.Value = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputConfigFilter(ctx context.Context, obj any) (configmap.ConfigFilter, error) { + var it configmap.ConfigFilter + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "inUse"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "inUse": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inUse")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.InUse = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputConfigOrder(ctx context.Context, obj any) (configmap.ConfigOrder, error) { + var it configmap.ConfigOrder + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"field", "direction"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "field": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) + data, err := ec.unmarshalNConfigOrderField2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigOrderField(ctx, v) + if err != nil { + return it, err + } + it.Field = data + case "direction": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) + data, err := ec.unmarshalNOrderDirection2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚐOrderDirection(ctx, v) + if err != nil { + return it, err + } + it.Direction = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputConfigValueInput(ctx context.Context, obj any) (configmap.ConfigValueInput, error) { + var it configmap.ConfigValueInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "value"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "value": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Value = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputCreateConfigInput(ctx context.Context, obj any) (configmap.CreateConfigInput, error) { + var it configmap.CreateConfigInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "environmentName", "teamSlug"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "environmentName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("environmentName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.EnvironmentName = data + case "teamSlug": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("teamSlug")) + data, err := ec.unmarshalNSlug2githubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug(ctx, v) + if err != nil { + return it, err + } + it.TeamSlug = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDeleteConfigInput(ctx context.Context, obj any) (configmap.DeleteConfigInput, error) { + var it configmap.DeleteConfigInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "environmentName", "teamSlug"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "environmentName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("environmentName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.EnvironmentName = data + case "teamSlug": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("teamSlug")) + data, err := ec.unmarshalNSlug2githubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug(ctx, v) + if err != nil { + return it, err + } + it.TeamSlug = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputRemoveConfigValueInput(ctx context.Context, obj any) (configmap.RemoveConfigValueInput, error) { + var it configmap.RemoveConfigValueInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"configName", "environmentName", "teamSlug", "valueName"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "configName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("configName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.ConfigName = data + case "environmentName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("environmentName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.EnvironmentName = data + case "teamSlug": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("teamSlug")) + data, err := ec.unmarshalNSlug2githubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug(ctx, v) + if err != nil { + return it, err + } + it.TeamSlug = data + case "valueName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("valueName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.ValueName = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputUpdateConfigValueInput(ctx context.Context, obj any) (configmap.UpdateConfigValueInput, error) { + var it configmap.UpdateConfigValueInput + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "environmentName", "teamSlug", "value"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "environmentName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("environmentName")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.EnvironmentName = data + case "teamSlug": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("teamSlug")) + data, err := ec.unmarshalNSlug2githubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug(ctx, v) + if err != nil { + return it, err + } + it.TeamSlug = data + case "value": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value")) + data, err := ec.unmarshalNConfigValueInput2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValueInput(ctx, v) + if err != nil { + return it, err + } + it.Value = data + } + } + return it, nil +} + +// endregion **************************** input.gotpl ***************************** + +// region ************************** interface.gotpl *************************** + +// endregion ************************** interface.gotpl *************************** + +// region **************************** object.gotpl **************************** + +var addConfigValuePayloadImplementors = []string{"AddConfigValuePayload"} + +func (ec *executionContext) _AddConfigValuePayload(ctx context.Context, sel ast.SelectionSet, obj *configmap.AddConfigValuePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, addConfigValuePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("AddConfigValuePayload") + case "config": + out.Values[i] = ec._AddConfigValuePayload_config(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configImplementors = []string{"Config", "Node", "ActivityLogger"} + +func (ec *executionContext) _Config(ctx context.Context, sel ast.SelectionSet, obj *configmap.Config) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("Config") + case "id": + out.Values[i] = ec._Config_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "name": + out.Values[i] = ec._Config_name(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "teamEnvironment": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_teamEnvironment(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "team": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_team(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "values": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_values(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "applications": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_applications(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "jobs": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_jobs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "workloads": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_workloads(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "lastModifiedAt": + out.Values[i] = ec._Config_lastModifiedAt(ctx, field, obj) + case "lastModifiedBy": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_lastModifiedBy(ctx, field, obj) + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "activityLog": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Config_activityLog(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configConnectionImplementors = []string{"ConfigConnection"} + +func (ec *executionContext) _ConfigConnection(ctx context.Context, sel ast.SelectionSet, obj *pagination.Connection[*configmap.Config]) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configConnectionImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigConnection") + case "pageInfo": + out.Values[i] = ec._ConfigConnection_pageInfo(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "nodes": + out.Values[i] = ec._ConfigConnection_nodes(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "edges": + out.Values[i] = ec._ConfigConnection_edges(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configCreatedActivityLogEntryImplementors = []string{"ConfigCreatedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _ConfigCreatedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *configmap.ConfigCreatedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configCreatedActivityLogEntryImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigCreatedActivityLogEntry") + case "id": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._ConfigCreatedActivityLogEntry_environmentName(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configDeletedActivityLogEntryImplementors = []string{"ConfigDeletedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _ConfigDeletedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *configmap.ConfigDeletedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configDeletedActivityLogEntryImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigDeletedActivityLogEntry") + case "id": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._ConfigDeletedActivityLogEntry_environmentName(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configEdgeImplementors = []string{"ConfigEdge"} + +func (ec *executionContext) _ConfigEdge(ctx context.Context, sel ast.SelectionSet, obj *pagination.Edge[*configmap.Config]) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configEdgeImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigEdge") + case "cursor": + out.Values[i] = ec._ConfigEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "node": + out.Values[i] = ec._ConfigEdge_node(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configUpdatedActivityLogEntryImplementors = []string{"ConfigUpdatedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *configmap.ConfigUpdatedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configUpdatedActivityLogEntryImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigUpdatedActivityLogEntry") + case "id": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._ConfigUpdatedActivityLogEntry_data(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configUpdatedActivityLogEntryDataImplementors = []string{"ConfigUpdatedActivityLogEntryData"} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *configmap.ConfigUpdatedActivityLogEntryData) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configUpdatedActivityLogEntryDataImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigUpdatedActivityLogEntryData") + case "updatedFields": + out.Values[i] = ec._ConfigUpdatedActivityLogEntryData_updatedFields(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configUpdatedActivityLogEntryDataUpdatedFieldImplementors = []string{"ConfigUpdatedActivityLogEntryDataUpdatedField"} + +func (ec *executionContext) _ConfigUpdatedActivityLogEntryDataUpdatedField(ctx context.Context, sel ast.SelectionSet, obj *configmap.ConfigUpdatedActivityLogEntryDataUpdatedField) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configUpdatedActivityLogEntryDataUpdatedFieldImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigUpdatedActivityLogEntryDataUpdatedField") + case "field": + out.Values[i] = ec._ConfigUpdatedActivityLogEntryDataUpdatedField_field(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "oldValue": + out.Values[i] = ec._ConfigUpdatedActivityLogEntryDataUpdatedField_oldValue(ctx, field, obj) + case "newValue": + out.Values[i] = ec._ConfigUpdatedActivityLogEntryDataUpdatedField_newValue(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configValueImplementors = []string{"ConfigValue"} + +func (ec *executionContext) _ConfigValue(ctx context.Context, sel ast.SelectionSet, obj *configmap.ConfigValue) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configValueImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigValue") + case "name": + out.Values[i] = ec._ConfigValue_name(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "value": + out.Values[i] = ec._ConfigValue_value(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var createConfigPayloadImplementors = []string{"CreateConfigPayload"} + +func (ec *executionContext) _CreateConfigPayload(ctx context.Context, sel ast.SelectionSet, obj *configmap.CreateConfigPayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, createConfigPayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("CreateConfigPayload") + case "config": + out.Values[i] = ec._CreateConfigPayload_config(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var deleteConfigPayloadImplementors = []string{"DeleteConfigPayload"} + +func (ec *executionContext) _DeleteConfigPayload(ctx context.Context, sel ast.SelectionSet, obj *configmap.DeleteConfigPayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, deleteConfigPayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("DeleteConfigPayload") + case "configDeleted": + out.Values[i] = ec._DeleteConfigPayload_configDeleted(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var removeConfigValuePayloadImplementors = []string{"RemoveConfigValuePayload"} + +func (ec *executionContext) _RemoveConfigValuePayload(ctx context.Context, sel ast.SelectionSet, obj *configmap.RemoveConfigValuePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, removeConfigValuePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("RemoveConfigValuePayload") + case "config": + out.Values[i] = ec._RemoveConfigValuePayload_config(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var teamInventoryCountConfigsImplementors = []string{"TeamInventoryCountConfigs"} + +func (ec *executionContext) _TeamInventoryCountConfigs(ctx context.Context, sel ast.SelectionSet, obj *configmap.TeamInventoryCountConfigs) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, teamInventoryCountConfigsImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("TeamInventoryCountConfigs") + case "total": + out.Values[i] = ec._TeamInventoryCountConfigs_total(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var updateConfigValuePayloadImplementors = []string{"UpdateConfigValuePayload"} + +func (ec *executionContext) _UpdateConfigValuePayload(ctx context.Context, sel ast.SelectionSet, obj *configmap.UpdateConfigValuePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, updateConfigValuePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("UpdateConfigValuePayload") + case "config": + out.Values[i] = ec._UpdateConfigValuePayload_config(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +// endregion **************************** object.gotpl **************************** + +// region ***************************** type.gotpl ***************************** + +func (ec *executionContext) unmarshalNAddConfigValueInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐAddConfigValueInput(ctx context.Context, v any) (configmap.AddConfigValueInput, error) { + res, err := ec.unmarshalInputAddConfigValueInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNAddConfigValuePayload2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐAddConfigValuePayload(ctx context.Context, sel ast.SelectionSet, v configmap.AddConfigValuePayload) graphql.Marshaler { + return ec._AddConfigValuePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNAddConfigValuePayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐAddConfigValuePayload(ctx context.Context, sel ast.SelectionSet, v *configmap.AddConfigValuePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._AddConfigValuePayload(ctx, sel, v) +} + +func (ec *executionContext) marshalNConfig2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig(ctx context.Context, sel ast.SelectionSet, v configmap.Config) graphql.Marshaler { + return ec._Config(ctx, sel, &v) +} + +func (ec *executionContext) marshalNConfig2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigᚄ(ctx context.Context, sel ast.SelectionSet, v []*configmap.Config) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig(ctx context.Context, sel ast.SelectionSet, v *configmap.Config) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._Config(ctx, sel, v) +} + +func (ec *executionContext) marshalNConfigConnection2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection(ctx context.Context, sel ast.SelectionSet, v pagination.Connection[*configmap.Config]) graphql.Marshaler { + return ec._ConfigConnection(ctx, sel, &v) +} + +func (ec *executionContext) marshalNConfigConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection(ctx context.Context, sel ast.SelectionSet, v *pagination.Connection[*configmap.Config]) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ConfigConnection(ctx, sel, v) +} + +func (ec *executionContext) marshalNConfigEdge2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐEdge(ctx context.Context, sel ast.SelectionSet, v pagination.Edge[*configmap.Config]) graphql.Marshaler { + return ec._ConfigEdge(ctx, sel, &v) +} + +func (ec *executionContext) marshalNConfigEdge2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []pagination.Edge[*configmap.Config]) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNConfigEdge2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐEdge(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) unmarshalNConfigOrderField2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigOrderField(ctx context.Context, v any) (configmap.ConfigOrderField, error) { + var res configmap.ConfigOrderField + err := res.UnmarshalGQL(v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNConfigOrderField2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigOrderField(ctx context.Context, sel ast.SelectionSet, v configmap.ConfigOrderField) graphql.Marshaler { + return v +} + +func (ec *executionContext) marshalNConfigUpdatedActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigUpdatedActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, v *configmap.ConfigUpdatedActivityLogEntryData) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ConfigUpdatedActivityLogEntryData(ctx, sel, v) +} + +func (ec *executionContext) marshalNConfigUpdatedActivityLogEntryDataUpdatedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigUpdatedActivityLogEntryDataUpdatedFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []*configmap.ConfigUpdatedActivityLogEntryDataUpdatedField) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNConfigUpdatedActivityLogEntryDataUpdatedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigUpdatedActivityLogEntryDataUpdatedField(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNConfigUpdatedActivityLogEntryDataUpdatedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigUpdatedActivityLogEntryDataUpdatedField(ctx context.Context, sel ast.SelectionSet, v *configmap.ConfigUpdatedActivityLogEntryDataUpdatedField) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ConfigUpdatedActivityLogEntryDataUpdatedField(ctx, sel, v) +} + +func (ec *executionContext) marshalNConfigValue2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValueᚄ(ctx context.Context, sel ast.SelectionSet, v []*configmap.ConfigValue) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNConfigValue2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValue(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNConfigValue2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValue(ctx context.Context, sel ast.SelectionSet, v *configmap.ConfigValue) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ConfigValue(ctx, sel, v) +} + +func (ec *executionContext) unmarshalNConfigValueInput2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigValueInput(ctx context.Context, v any) (*configmap.ConfigValueInput, error) { + res, err := ec.unmarshalInputConfigValueInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalNCreateConfigInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐCreateConfigInput(ctx context.Context, v any) (configmap.CreateConfigInput, error) { + res, err := ec.unmarshalInputCreateConfigInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNCreateConfigPayload2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐCreateConfigPayload(ctx context.Context, sel ast.SelectionSet, v configmap.CreateConfigPayload) graphql.Marshaler { + return ec._CreateConfigPayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNCreateConfigPayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐCreateConfigPayload(ctx context.Context, sel ast.SelectionSet, v *configmap.CreateConfigPayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._CreateConfigPayload(ctx, sel, v) +} + +func (ec *executionContext) unmarshalNDeleteConfigInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐDeleteConfigInput(ctx context.Context, v any) (configmap.DeleteConfigInput, error) { + res, err := ec.unmarshalInputDeleteConfigInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNDeleteConfigPayload2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐDeleteConfigPayload(ctx context.Context, sel ast.SelectionSet, v configmap.DeleteConfigPayload) graphql.Marshaler { + return ec._DeleteConfigPayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNDeleteConfigPayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐDeleteConfigPayload(ctx context.Context, sel ast.SelectionSet, v *configmap.DeleteConfigPayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._DeleteConfigPayload(ctx, sel, v) +} + +func (ec *executionContext) unmarshalNRemoveConfigValueInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐRemoveConfigValueInput(ctx context.Context, v any) (configmap.RemoveConfigValueInput, error) { + res, err := ec.unmarshalInputRemoveConfigValueInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNRemoveConfigValuePayload2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐRemoveConfigValuePayload(ctx context.Context, sel ast.SelectionSet, v configmap.RemoveConfigValuePayload) graphql.Marshaler { + return ec._RemoveConfigValuePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNRemoveConfigValuePayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐRemoveConfigValuePayload(ctx context.Context, sel ast.SelectionSet, v *configmap.RemoveConfigValuePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._RemoveConfigValuePayload(ctx, sel, v) +} + +func (ec *executionContext) marshalNTeamInventoryCountConfigs2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐTeamInventoryCountConfigs(ctx context.Context, sel ast.SelectionSet, v configmap.TeamInventoryCountConfigs) graphql.Marshaler { + return ec._TeamInventoryCountConfigs(ctx, sel, &v) +} + +func (ec *executionContext) marshalNTeamInventoryCountConfigs2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐTeamInventoryCountConfigs(ctx context.Context, sel ast.SelectionSet, v *configmap.TeamInventoryCountConfigs) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._TeamInventoryCountConfigs(ctx, sel, v) +} + +func (ec *executionContext) unmarshalNUpdateConfigValueInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐUpdateConfigValueInput(ctx context.Context, v any) (configmap.UpdateConfigValueInput, error) { + res, err := ec.unmarshalInputUpdateConfigValueInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNUpdateConfigValuePayload2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐUpdateConfigValuePayload(ctx context.Context, sel ast.SelectionSet, v configmap.UpdateConfigValuePayload) graphql.Marshaler { + return ec._UpdateConfigValuePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNUpdateConfigValuePayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐUpdateConfigValuePayload(ctx context.Context, sel ast.SelectionSet, v *configmap.UpdateConfigValuePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._UpdateConfigValuePayload(ctx, sel, v) +} + +func (ec *executionContext) marshalOConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig(ctx context.Context, sel ast.SelectionSet, v *configmap.Config) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._Config(ctx, sel, v) +} + +func (ec *executionContext) unmarshalOConfigFilter2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigFilter(ctx context.Context, v any) (*configmap.ConfigFilter, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputConfigFilter(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalOConfigOrder2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigOrder(ctx context.Context, v any) (*configmap.ConfigOrder, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputConfigOrder(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +// endregion ***************************** type.gotpl ***************************** diff --git a/internal/graph/gengql/issues.generated.go b/internal/graph/gengql/issues.generated.go index 912dec80a..9d36e5a4f 100644 --- a/internal/graph/gengql/issues.generated.go +++ b/internal/graph/gengql/issues.generated.go @@ -179,6 +179,8 @@ func (ec *executionContext) fieldContext_DeprecatedIngressIssue_teamEnvironment( return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -351,6 +353,8 @@ func (ec *executionContext) fieldContext_DeprecatedIngressIssue_application(_ co return ec.fieldContext_Application_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Application_buckets(ctx, field) + case "configs": + return ec.fieldContext_Application_configs(ctx, field) case "cost": return ec.fieldContext_Application_cost(ctx, field) case "deployments": @@ -455,6 +459,8 @@ func (ec *executionContext) fieldContext_DeprecatedRegistryIssue_teamEnvironment return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -640,6 +646,8 @@ func (ec *executionContext) fieldContext_ExternalIngressCriticalVulnerabilityIss return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -883,6 +891,8 @@ func (ec *executionContext) fieldContext_FailedSynchronizationIssue_teamEnvironm return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1068,6 +1078,8 @@ func (ec *executionContext) fieldContext_InvalidSpecIssue_teamEnvironment(_ cont return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1420,6 +1432,8 @@ func (ec *executionContext) fieldContext_LastRunFailedIssue_teamEnvironment(_ co return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1563,6 +1577,8 @@ func (ec *executionContext) fieldContext_LastRunFailedIssue_job(_ context.Contex return ec.fieldContext_Job_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Job_buckets(ctx, field) + case "configs": + return ec.fieldContext_Job_configs(ctx, field) case "cost": return ec.fieldContext_Job_cost(ctx, field) case "deployments": @@ -1665,6 +1681,8 @@ func (ec *executionContext) fieldContext_MissingSbomIssue_teamEnvironment(_ cont return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1850,6 +1868,8 @@ func (ec *executionContext) fieldContext_NoRunningInstancesIssue_teamEnvironment return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -2035,6 +2055,8 @@ func (ec *executionContext) fieldContext_OpenSearchIssue_teamEnvironment(_ conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -2285,6 +2307,8 @@ func (ec *executionContext) fieldContext_SqlInstanceStateIssue_teamEnvironment(_ return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -2555,6 +2579,8 @@ func (ec *executionContext) fieldContext_SqlInstanceVersionIssue_teamEnvironment return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -2796,6 +2822,8 @@ func (ec *executionContext) fieldContext_UnleashReleaseChannelIssue_teamEnvironm return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -3090,6 +3118,8 @@ func (ec *executionContext) fieldContext_ValkeyIssue_teamEnvironment(_ context.C return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -3340,6 +3370,8 @@ func (ec *executionContext) fieldContext_VulnerableImageIssue_teamEnvironment(_ return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/jobs.generated.go b/internal/graph/gengql/jobs.generated.go index b5494106e..85a5248ce 100644 --- a/internal/graph/gengql/jobs.generated.go +++ b/internal/graph/gengql/jobs.generated.go @@ -26,6 +26,7 @@ import ( "github.com/nais/api/internal/team" "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/logging" "github.com/nais/api/internal/workload/netpol" @@ -53,6 +54,7 @@ type JobResolver interface { Issues(ctx context.Context, obj *job.Job, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *issue.IssueOrder, filter *issue.ResourceIssueFilter) (*pagination.Connection[issue.Issue], error) BigQueryDatasets(ctx context.Context, obj *job.Job, orderBy *bigquery.BigQueryDatasetOrder) (*pagination.Connection[*bigquery.BigQueryDataset], error) Buckets(ctx context.Context, obj *job.Job, orderBy *bucket.BucketOrder) (*pagination.Connection[*bucket.Bucket], error) + Configs(ctx context.Context, obj *job.Job, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*configmap.Config], error) Cost(ctx context.Context, obj *job.Job) (*cost.WorkloadCost, error) Deployments(ctx context.Context, obj *job.Job, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*deployment.Deployment], error) KafkaTopicAcls(ctx context.Context, obj *job.Job, orderBy *kafkatopic.KafkaTopicACLOrder) (*pagination.Connection[*kafkatopic.KafkaTopicACL], error) @@ -157,6 +159,32 @@ func (ec *executionContext) field_Job_buckets_args(ctx context.Context, rawArgs return args, nil } +func (ec *executionContext) field_Job_configs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + return args, nil +} + func (ec *executionContext) field_Job_deployments_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -409,6 +437,8 @@ func (ec *executionContext) fieldContext_DeleteJobPayload_team(_ context.Context return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -607,6 +637,8 @@ func (ec *executionContext) fieldContext_Job_team(_ context.Context, field graph return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -696,6 +728,8 @@ func (ec *executionContext) fieldContext_Job_environment(_ context.Context, fiel return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -765,6 +799,8 @@ func (ec *executionContext) fieldContext_Job_teamEnvironment(_ context.Context, return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1274,6 +1310,55 @@ func (ec *executionContext) fieldContext_Job_buckets(ctx context.Context, field return fc, nil } +func (ec *executionContext) _Job_configs(ctx context.Context, field graphql.CollectedField, obj *job.Job) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Job_configs, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Job().Configs(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor)) + }, + nil, + ec.marshalNConfigConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Job_configs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Job", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_ConfigConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_ConfigConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_ConfigConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Job_configs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Job_cost(ctx context.Context, field graphql.CollectedField, obj *job.Job) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -1925,6 +2010,8 @@ func (ec *executionContext) fieldContext_JobConnection_nodes(_ context.Context, return ec.fieldContext_Job_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Job_buckets(ctx, field) + case "configs": + return ec.fieldContext_Job_configs(ctx, field) case "cost": return ec.fieldContext_Job_cost(ctx, field) case "deployments": @@ -2310,6 +2397,8 @@ func (ec *executionContext) fieldContext_JobEdge_node(_ context.Context, field g return ec.fieldContext_Job_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Job_buckets(ctx, field) + case "configs": + return ec.fieldContext_Job_configs(ctx, field) case "cost": return ec.fieldContext_Job_cost(ctx, field) case "deployments": @@ -3688,6 +3777,8 @@ func (ec *executionContext) fieldContext_TriggerJobPayload_job(_ context.Context return ec.fieldContext_Job_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Job_buckets(ctx, field) + case "configs": + return ec.fieldContext_Job_configs(ctx, field) case "cost": return ec.fieldContext_Job_cost(ctx, field) case "deployments": @@ -4459,6 +4550,42 @@ func (ec *executionContext) _Job(ctx context.Context, sel ast.SelectionSet, obj continue } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "configs": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Job_configs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) case "cost": field := field diff --git a/internal/graph/gengql/kafka.generated.go b/internal/graph/gengql/kafka.generated.go index a96330a97..fff148e66 100644 --- a/internal/graph/gengql/kafka.generated.go +++ b/internal/graph/gengql/kafka.generated.go @@ -201,6 +201,8 @@ func (ec *executionContext) fieldContext_KafkaTopic_team(_ context.Context, fiel return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -290,6 +292,8 @@ func (ec *executionContext) fieldContext_KafkaTopic_environment(_ context.Contex return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -359,6 +363,8 @@ func (ec *executionContext) fieldContext_KafkaTopic_teamEnvironment(_ context.Co return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -662,6 +668,8 @@ func (ec *executionContext) fieldContext_KafkaTopicAcl_team(_ context.Context, f return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": diff --git a/internal/graph/gengql/netpol.generated.go b/internal/graph/gengql/netpol.generated.go index 07dcd9b5f..304f8a1bc 100644 --- a/internal/graph/gengql/netpol.generated.go +++ b/internal/graph/gengql/netpol.generated.go @@ -413,6 +413,8 @@ func (ec *executionContext) fieldContext_NetworkPolicyRule_targetTeam(_ context. return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": diff --git a/internal/graph/gengql/opensearch.generated.go b/internal/graph/gengql/opensearch.generated.go index cf573951a..44281d956 100644 --- a/internal/graph/gengql/opensearch.generated.go +++ b/internal/graph/gengql/opensearch.generated.go @@ -368,6 +368,8 @@ func (ec *executionContext) fieldContext_OpenSearch_team(_ context.Context, fiel return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -457,6 +459,8 @@ func (ec *executionContext) fieldContext_OpenSearch_environment(_ context.Contex return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -526,6 +530,8 @@ func (ec *executionContext) fieldContext_OpenSearch_teamEnvironment(_ context.Co return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/postgres.generated.go b/internal/graph/gengql/postgres.generated.go index 8e8c5db8a..281d660f4 100644 --- a/internal/graph/gengql/postgres.generated.go +++ b/internal/graph/gengql/postgres.generated.go @@ -543,6 +543,8 @@ func (ec *executionContext) fieldContext_PostgresInstance_team(_ context.Context return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -632,6 +634,8 @@ func (ec *executionContext) fieldContext_PostgresInstance_environment(_ context. return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -701,6 +705,8 @@ func (ec *executionContext) fieldContext_PostgresInstance_teamEnvironment(_ cont return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/reconcilers.generated.go b/internal/graph/gengql/reconcilers.generated.go index f95377f53..9e3287a04 100644 --- a/internal/graph/gengql/reconcilers.generated.go +++ b/internal/graph/gengql/reconcilers.generated.go @@ -1732,6 +1732,8 @@ func (ec *executionContext) fieldContext_ReconcilerError_team(_ context.Context, return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": diff --git a/internal/graph/gengql/repository.generated.go b/internal/graph/gengql/repository.generated.go index 6c596fe5c..8a9dcd722 100644 --- a/internal/graph/gengql/repository.generated.go +++ b/internal/graph/gengql/repository.generated.go @@ -222,6 +222,8 @@ func (ec *executionContext) fieldContext_Repository_team(_ context.Context, fiel return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index 15832f6fb..3dc2875ae 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -40,6 +40,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/podlog" "github.com/nais/api/internal/workload/secret" @@ -60,6 +61,7 @@ type ResolverRoot interface { BigQueryDataset() BigQueryDatasetResolver Bucket() BucketResolver CVE() CVEResolver + Config() ConfigResolver ContainerImage() ContainerImageResolver ContainerImageWorkloadReference() ContainerImageWorkloadReferenceResolver CurrentUnitPrices() CurrentUnitPricesResolver @@ -148,6 +150,10 @@ type ComplexityRoot struct { Node func(childComplexity int) int } + AddConfigValuePayload struct { + Config func(childComplexity int) int + } + AddRepositoryToTeamPayload struct { Repository func(childComplexity int) int } @@ -180,6 +186,7 @@ type ComplexityRoot struct { AuthIntegrations func(childComplexity int) int BigQueryDatasets func(childComplexity int, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, orderBy *bucket.BucketOrder) int + Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int Cost func(childComplexity int) int DeletionStartedAt func(childComplexity int) int Deployments func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int @@ -432,6 +439,80 @@ type ComplexityRoot struct { ResourceKind func(childComplexity int) int } + Config struct { + ActivityLog func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int + Applications func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int + ID func(childComplexity int) int + Jobs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int + LastModifiedAt func(childComplexity int) int + LastModifiedBy func(childComplexity int) int + Name func(childComplexity int) int + Team func(childComplexity int) int + TeamEnvironment func(childComplexity int) int + Values func(childComplexity int) int + Workloads func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int + } + + ConfigConnection struct { + Edges func(childComplexity int) int + Nodes func(childComplexity int) int + PageInfo func(childComplexity int) int + } + + ConfigCreatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ConfigDeletedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ConfigEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + + ConfigUpdatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ConfigUpdatedActivityLogEntryData struct { + UpdatedFields func(childComplexity int) int + } + + ConfigUpdatedActivityLogEntryDataUpdatedField struct { + Field func(childComplexity int) int + NewValue func(childComplexity int) int + OldValue func(childComplexity int) int + } + + ConfigValue struct { + Name func(childComplexity int) int + Value func(childComplexity int) int + } + ConfirmTeamDeletionPayload struct { DeletionStarted func(childComplexity int) int } @@ -466,6 +547,10 @@ type ComplexityRoot struct { Series func(childComplexity int) int } + CreateConfigPayload struct { + Config func(childComplexity int) int + } + CreateKafkaCredentialsPayload struct { Credentials func(childComplexity int) int } @@ -537,6 +622,10 @@ type ComplexityRoot struct { Team func(childComplexity int) int } + DeleteConfigPayload struct { + ConfigDeleted func(childComplexity int) int + } + DeleteJobPayload struct { Success func(childComplexity int) int Team func(childComplexity int) int @@ -845,6 +934,7 @@ type ComplexityRoot struct { AuthIntegrations func(childComplexity int) int BigQueryDatasets func(childComplexity int, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, orderBy *bucket.BucketOrder) int + Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int Cost func(childComplexity int) int DeletionStartedAt func(childComplexity int) int Deployments func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int @@ -1107,6 +1197,7 @@ type ComplexityRoot struct { } Mutation struct { + AddConfigValue func(childComplexity int, input configmap.AddConfigValueInput) int AddRepositoryToTeam func(childComplexity int, input repository.AddRepositoryToTeamInput) int AddSecretValue func(childComplexity int, input secret.AddSecretValueInput) int AddTeamMember func(childComplexity int, input team.AddTeamMemberInput) int @@ -1115,6 +1206,7 @@ type ComplexityRoot struct { ChangeDeploymentKey func(childComplexity int, input deployment.ChangeDeploymentKeyInput) int ConfigureReconciler func(childComplexity int, input reconciler.ConfigureReconcilerInput) int ConfirmTeamDeletion func(childComplexity int, input team.ConfirmTeamDeletionInput) int + CreateConfig func(childComplexity int, input configmap.CreateConfigInput) int CreateKafkaCredentials func(childComplexity int, input aivencredentials.CreateKafkaCredentialsInput) int CreateOpenSearch func(childComplexity int, input opensearch.CreateOpenSearchInput) int CreateOpenSearchCredentials func(childComplexity int, input aivencredentials.CreateOpenSearchCredentialsInput) int @@ -1126,6 +1218,7 @@ type ComplexityRoot struct { CreateValkey func(childComplexity int, input valkey.CreateValkeyInput) int CreateValkeyCredentials func(childComplexity int, input aivencredentials.CreateValkeyCredentialsInput) int DeleteApplication func(childComplexity int, input application.DeleteApplicationInput) int + DeleteConfig func(childComplexity int, input configmap.DeleteConfigInput) int DeleteJob func(childComplexity int, input job.DeleteJobInput) int DeleteOpenSearch func(childComplexity int, input opensearch.DeleteOpenSearchInput) int DeleteSecret func(childComplexity int, input secret.DeleteSecretInput) int @@ -1136,6 +1229,7 @@ type ComplexityRoot struct { DisableReconciler func(childComplexity int, input reconciler.DisableReconcilerInput) int EnableReconciler func(childComplexity int, input reconciler.EnableReconcilerInput) int GrantPostgresAccess func(childComplexity int, input postgres.GrantPostgresAccessInput) int + RemoveConfigValue func(childComplexity int, input configmap.RemoveConfigValueInput) int RemoveRepositoryFromTeam func(childComplexity int, input repository.RemoveRepositoryFromTeamInput) int RemoveSecretValue func(childComplexity int, input secret.RemoveSecretValueInput) int RemoveTeamMember func(childComplexity int, input team.RemoveTeamMemberInput) int @@ -1147,6 +1241,7 @@ type ComplexityRoot struct { StartOpenSearchMaintenance func(childComplexity int, input servicemaintenance.StartOpenSearchMaintenanceInput) int StartValkeyMaintenance func(childComplexity int, input servicemaintenance.StartValkeyMaintenanceInput) int TriggerJob func(childComplexity int, input job.TriggerJobInput) int + UpdateConfigValue func(childComplexity int, input configmap.UpdateConfigValueInput) int UpdateImageVulnerability func(childComplexity int, input vulnerability.UpdateImageVulnerabilityInput) int UpdateOpenSearch func(childComplexity int, input opensearch.UpdateOpenSearchInput) int UpdateSecretValue func(childComplexity int, input secret.UpdateSecretValueInput) int @@ -1537,6 +1632,10 @@ type ComplexityRoot struct { Node func(childComplexity int) int } + RemoveConfigValuePayload struct { + Config func(childComplexity int) int + } + RemoveRepositoryFromTeamPayload struct { Success func(childComplexity int) int } @@ -2134,6 +2233,7 @@ type ComplexityRoot struct { Applications func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *application.ApplicationOrder, filter *application.TeamApplicationsFilter) int BigQueryDatasets func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bucket.BucketOrder) int + Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *configmap.ConfigOrder, filter *configmap.ConfigFilter) int Cost func(childComplexity int) int DeleteKey func(childComplexity int, key string) int DeletionInProgress func(childComplexity int) int @@ -2267,6 +2367,7 @@ type ComplexityRoot struct { Application func(childComplexity int, name string) int BigQueryDataset func(childComplexity int, name string) int Bucket func(childComplexity int, name string) int + Config func(childComplexity int, name string) int Cost func(childComplexity int) int Environment func(childComplexity int) int GCPProjectID func(childComplexity int) int @@ -2347,6 +2448,10 @@ type ComplexityRoot struct { Total func(childComplexity int) int } + TeamInventoryCountConfigs struct { + Total func(childComplexity int) int + } + TeamInventoryCountJobs struct { Total func(childComplexity int) int } @@ -2379,6 +2484,7 @@ type ComplexityRoot struct { Applications func(childComplexity int) int BigQueryDatasets func(childComplexity int) int Buckets func(childComplexity int) int + Configs func(childComplexity int) int Jobs func(childComplexity int) int KafkaTopics func(childComplexity int) int OpenSearches func(childComplexity int) int @@ -2630,6 +2736,10 @@ type ComplexityRoot struct { Unleash func(childComplexity int) int } + UpdateConfigValuePayload struct { + Config func(childComplexity int) int + } + UpdateImageVulnerabilityPayload struct { Vulnerability func(childComplexity int) int } @@ -3067,6 +3177,13 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ActivityLogEntryEdge.Node(childComplexity), true + case "AddConfigValuePayload.config": + if e.ComplexityRoot.AddConfigValuePayload.Config == nil { + break + } + + return e.ComplexityRoot.AddConfigValuePayload.Config(childComplexity), true + case "AddRepositoryToTeamPayload.repository": if e.ComplexityRoot.AddRepositoryToTeamPayload.Repository == nil { break @@ -3173,6 +3290,18 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.Application.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true + case "Application.configs": + if e.ComplexityRoot.Application.Configs == nil { + break + } + + args, err := ec.field_Application_configs_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.Application.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + case "Application.cost": if e.ComplexityRoot.Application.Cost == nil { break @@ -4274,11619 +4403,12434 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ClusterAuditActivityLogEntryData.ResourceKind(childComplexity), true - case "ConfirmTeamDeletionPayload.deletionStarted": - if e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted == nil { + case "Config.activityLog": + if e.ComplexityRoot.Config.ActivityLog == nil { break } - return e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted(childComplexity), true + args, err := ec.field_Config_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ContainerImage.activityLog": - if e.ComplexityRoot.ContainerImage.ActivityLog == nil { + return e.ComplexityRoot.Config.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + + case "Config.applications": + if e.ComplexityRoot.Config.Applications == nil { break } - args, err := ec.field_ContainerImage_activityLog_args(ctx, rawArgs) + args, err := ec.field_Config_applications_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ContainerImage.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Config.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ContainerImage.hasSBOM": - if e.ComplexityRoot.ContainerImage.HasSbom == nil { + case "Config.id": + if e.ComplexityRoot.Config.ID == nil { break } - return e.ComplexityRoot.ContainerImage.HasSbom(childComplexity), true + return e.ComplexityRoot.Config.ID(childComplexity), true - case "ContainerImage.id": - if e.ComplexityRoot.ContainerImage.ID == nil { + case "Config.jobs": + if e.ComplexityRoot.Config.Jobs == nil { break } - return e.ComplexityRoot.ContainerImage.ID(childComplexity), true + args, err := ec.field_Config_jobs_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ContainerImage.name": - if e.ComplexityRoot.ContainerImage.Name == nil { + return e.ComplexityRoot.Config.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Config.lastModifiedAt": + if e.ComplexityRoot.Config.LastModifiedAt == nil { break } - return e.ComplexityRoot.ContainerImage.Name(childComplexity), true + return e.ComplexityRoot.Config.LastModifiedAt(childComplexity), true - case "ContainerImage.tag": - if e.ComplexityRoot.ContainerImage.Tag == nil { + case "Config.lastModifiedBy": + if e.ComplexityRoot.Config.LastModifiedBy == nil { break } - return e.ComplexityRoot.ContainerImage.Tag(childComplexity), true + return e.ComplexityRoot.Config.LastModifiedBy(childComplexity), true - case "ContainerImage.vulnerabilities": - if e.ComplexityRoot.ContainerImage.Vulnerabilities == nil { + case "Config.name": + if e.ComplexityRoot.Config.Name == nil { break } - args, err := ec.field_ContainerImage_vulnerabilities_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Config.Name(childComplexity), true + + case "Config.team": + if e.ComplexityRoot.Config.Team == nil { + break } - return e.ComplexityRoot.ContainerImage.Vulnerabilities(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*vulnerability.ImageVulnerabilityFilter), args["orderBy"].(*vulnerability.ImageVulnerabilityOrder)), true + return e.ComplexityRoot.Config.Team(childComplexity), true - case "ContainerImage.vulnerabilitySummary": - if e.ComplexityRoot.ContainerImage.VulnerabilitySummary == nil { + case "Config.teamEnvironment": + if e.ComplexityRoot.Config.TeamEnvironment == nil { break } - return e.ComplexityRoot.ContainerImage.VulnerabilitySummary(childComplexity), true + return e.ComplexityRoot.Config.TeamEnvironment(childComplexity), true - case "ContainerImage.workloadReferences": - if e.ComplexityRoot.ContainerImage.WorkloadReferences == nil { + case "Config.values": + if e.ComplexityRoot.Config.Values == nil { break } - args, err := ec.field_ContainerImage_workloadReferences_args(ctx, rawArgs) + return e.ComplexityRoot.Config.Values(childComplexity), true + + case "Config.workloads": + if e.ComplexityRoot.Config.Workloads == nil { + break + } + + args, err := ec.field_Config_workloads_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ContainerImage.WorkloadReferences(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Config.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ContainerImageWorkloadReference.workload": - if e.ComplexityRoot.ContainerImageWorkloadReference.Workload == nil { + case "ConfigConnection.edges": + if e.ComplexityRoot.ConfigConnection.Edges == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReference.Workload(childComplexity), true + return e.ComplexityRoot.ConfigConnection.Edges(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.edges": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges == nil { + case "ConfigConnection.nodes": + if e.ComplexityRoot.ConfigConnection.Nodes == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges(childComplexity), true + return e.ComplexityRoot.ConfigConnection.Nodes(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.nodes": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes == nil { + case "ConfigConnection.pageInfo": + if e.ComplexityRoot.ConfigConnection.PageInfo == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ConfigConnection.PageInfo(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.pageInfo": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo == nil { + case "ConfigCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.Actor(childComplexity), true - case "ContainerImageWorkloadReferenceEdge.cursor": - if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor == nil { + case "ConfigCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "ContainerImageWorkloadReferenceEdge.node": - if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node == nil { + case "ConfigCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "CostMonthlySummary.series": - if e.ComplexityRoot.CostMonthlySummary.Series == nil { + case "ConfigCreatedActivityLogEntry.id": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.CostMonthlySummary.Series(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ID(childComplexity), true - case "CreateKafkaCredentialsPayload.credentials": - if e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials == nil { + case "ConfigCreatedActivityLogEntry.message": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.Message(childComplexity), true - case "CreateOpenSearchCredentialsPayload.credentials": - if e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials == nil { + case "ConfigCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceName(childComplexity), true - case "CreateOpenSearchPayload.openSearch": - if e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch == nil { + case "ConfigCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceType(childComplexity), true - case "CreateSecretPayload.secret": - if e.ComplexityRoot.CreateSecretPayload.Secret == nil { + case "ConfigCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.CreateSecretPayload.Secret(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "CreateServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount == nil { + case "ConfigDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.Actor(childComplexity), true - case "CreateServiceAccountTokenPayload.secret": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret == nil { + case "ConfigDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "CreateServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount == nil { + case "ConfigDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "CreateServiceAccountTokenPayload.serviceAccountToken": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken == nil { + case "ConfigDeletedActivityLogEntry.id": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ID(childComplexity), true - case "CreateTeamPayload.team": - if e.ComplexityRoot.CreateTeamPayload.Team == nil { + case "ConfigDeletedActivityLogEntry.message": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.CreateTeamPayload.Team(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.Message(childComplexity), true - case "CreateUnleashForTeamPayload.unleash": - if e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash == nil { + case "ConfigDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceName(childComplexity), true - case "CreateValkeyCredentialsPayload.credentials": - if e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials == nil { + case "ConfigDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceType(childComplexity), true - case "CreateValkeyPayload.valkey": - if e.ComplexityRoot.CreateValkeyPayload.Valkey == nil { + case "ConfigDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.CreateValkeyPayload.Valkey(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "CredentialsActivityLogEntry.actor": - if e.ComplexityRoot.CredentialsActivityLogEntry.Actor == nil { + case "ConfigEdge.cursor": + if e.ComplexityRoot.ConfigEdge.Cursor == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ConfigEdge.Cursor(childComplexity), true - case "CredentialsActivityLogEntry.createdAt": - if e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt == nil { + case "ConfigEdge.node": + if e.ComplexityRoot.ConfigEdge.Node == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ConfigEdge.Node(childComplexity), true - case "CredentialsActivityLogEntry.data": - if e.ComplexityRoot.CredentialsActivityLogEntry.Data == nil { + case "ConfigUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Actor(childComplexity), true - case "CredentialsActivityLogEntry.environmentName": - if e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName == nil { + case "ConfigUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "CredentialsActivityLogEntry.id": - if e.ComplexityRoot.CredentialsActivityLogEntry.ID == nil { + case "ConfigUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Data(childComplexity), true - case "CredentialsActivityLogEntry.message": - if e.ComplexityRoot.CredentialsActivityLogEntry.Message == nil { + case "ConfigUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "CredentialsActivityLogEntry.resourceName": - if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName == nil { + case "ConfigUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ID(childComplexity), true - case "CredentialsActivityLogEntry.resourceType": - if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType == nil { + case "ConfigUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Message(childComplexity), true - case "CredentialsActivityLogEntry.teamSlug": - if e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug == nil { + case "ConfigUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "CredentialsActivityLogEntryData.instanceName": - if e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName == nil { + case "ConfigUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "CredentialsActivityLogEntryData.permission": - if e.ComplexityRoot.CredentialsActivityLogEntryData.Permission == nil { + case "ConfigUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.Permission(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "CredentialsActivityLogEntryData.serviceType": - if e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType == nil { + case "ConfigUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "CredentialsActivityLogEntryData.ttl": - if e.ComplexityRoot.CredentialsActivityLogEntryData.TTL == nil { + case "ConfigUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.TTL(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "CurrentUnitPrices.cpu": - if e.ComplexityRoot.CurrentUnitPrices.CPU == nil { + case "ConfigUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.CurrentUnitPrices.CPU(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "CurrentUnitPrices.memory": - if e.ComplexityRoot.CurrentUnitPrices.Memory == nil { + case "ConfigUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.CurrentUnitPrices.Memory(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "DeleteApplicationPayload.success": - if e.ComplexityRoot.DeleteApplicationPayload.Success == nil { + case "ConfigValue.name": + if e.ComplexityRoot.ConfigValue.Name == nil { break } - return e.ComplexityRoot.DeleteApplicationPayload.Success(childComplexity), true + return e.ComplexityRoot.ConfigValue.Name(childComplexity), true - case "DeleteApplicationPayload.team": - if e.ComplexityRoot.DeleteApplicationPayload.Team == nil { + case "ConfigValue.value": + if e.ComplexityRoot.ConfigValue.Value == nil { break } - return e.ComplexityRoot.DeleteApplicationPayload.Team(childComplexity), true + return e.ComplexityRoot.ConfigValue.Value(childComplexity), true - case "DeleteJobPayload.success": - if e.ComplexityRoot.DeleteJobPayload.Success == nil { + case "ConfirmTeamDeletionPayload.deletionStarted": + if e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted == nil { break } - return e.ComplexityRoot.DeleteJobPayload.Success(childComplexity), true + return e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted(childComplexity), true - case "DeleteJobPayload.team": - if e.ComplexityRoot.DeleteJobPayload.Team == nil { + case "ContainerImage.activityLog": + if e.ComplexityRoot.ContainerImage.ActivityLog == nil { break } - return e.ComplexityRoot.DeleteJobPayload.Team(childComplexity), true - - case "DeleteOpenSearchPayload.openSearchDeleted": - if e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted == nil { - break + args, err := ec.field_ContainerImage_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted(childComplexity), true + return e.ComplexityRoot.ContainerImage.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "DeleteSecretPayload.secretDeleted": - if e.ComplexityRoot.DeleteSecretPayload.SecretDeleted == nil { + case "ContainerImage.hasSBOM": + if e.ComplexityRoot.ContainerImage.HasSbom == nil { break } - return e.ComplexityRoot.DeleteSecretPayload.SecretDeleted(childComplexity), true + return e.ComplexityRoot.ContainerImage.HasSbom(childComplexity), true - case "DeleteServiceAccountPayload.serviceAccountDeleted": - if e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted == nil { + case "ContainerImage.id": + if e.ComplexityRoot.ContainerImage.ID == nil { break } - return e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted(childComplexity), true + return e.ComplexityRoot.ContainerImage.ID(childComplexity), true - case "DeleteServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount == nil { + case "ContainerImage.name": + if e.ComplexityRoot.ContainerImage.Name == nil { break } - return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ContainerImage.Name(childComplexity), true - case "DeleteServiceAccountTokenPayload.serviceAccountTokenDeleted": - if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted == nil { + case "ContainerImage.tag": + if e.ComplexityRoot.ContainerImage.Tag == nil { break } - return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted(childComplexity), true + return e.ComplexityRoot.ContainerImage.Tag(childComplexity), true - case "DeleteUnleashInstancePayload.unleashDeleted": - if e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted == nil { + case "ContainerImage.vulnerabilities": + if e.ComplexityRoot.ContainerImage.Vulnerabilities == nil { break } - return e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted(childComplexity), true - - case "DeleteValkeyPayload.valkeyDeleted": - if e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted == nil { - break + args, err := ec.field_ContainerImage_vulnerabilities_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted(childComplexity), true + return e.ComplexityRoot.ContainerImage.Vulnerabilities(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*vulnerability.ImageVulnerabilityFilter), args["orderBy"].(*vulnerability.ImageVulnerabilityOrder)), true - case "Deployment.commitSha": - if e.ComplexityRoot.Deployment.CommitSha == nil { + case "ContainerImage.vulnerabilitySummary": + if e.ComplexityRoot.ContainerImage.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.Deployment.CommitSha(childComplexity), true + return e.ComplexityRoot.ContainerImage.VulnerabilitySummary(childComplexity), true - case "Deployment.createdAt": - if e.ComplexityRoot.Deployment.CreatedAt == nil { + case "ContainerImage.workloadReferences": + if e.ComplexityRoot.ContainerImage.WorkloadReferences == nil { break } - return e.ComplexityRoot.Deployment.CreatedAt(childComplexity), true - - case "Deployment.deployerUsername": - if e.ComplexityRoot.Deployment.DeployerUsername == nil { - break + args, err := ec.field_ContainerImage_workloadReferences_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Deployment.DeployerUsername(childComplexity), true + return e.ComplexityRoot.ContainerImage.WorkloadReferences(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Deployment.environmentName": - if e.ComplexityRoot.Deployment.EnvironmentName == nil { + case "ContainerImageWorkloadReference.workload": + if e.ComplexityRoot.ContainerImageWorkloadReference.Workload == nil { break } - return e.ComplexityRoot.Deployment.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReference.Workload(childComplexity), true - case "Deployment.id": - if e.ComplexityRoot.Deployment.ID == nil { + case "ContainerImageWorkloadReferenceConnection.edges": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges == nil { break } - return e.ComplexityRoot.Deployment.ID(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges(childComplexity), true - case "Deployment.repository": - if e.ComplexityRoot.Deployment.Repository == nil { + case "ContainerImageWorkloadReferenceConnection.nodes": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes == nil { break } - return e.ComplexityRoot.Deployment.Repository(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes(childComplexity), true - case "Deployment.resources": - if e.ComplexityRoot.Deployment.Resources == nil { + case "ContainerImageWorkloadReferenceConnection.pageInfo": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo == nil { break } - args, err := ec.field_Deployment_resources_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Deployment.Resources(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo(childComplexity), true - case "Deployment.statuses": - if e.ComplexityRoot.Deployment.Statuses == nil { + case "ContainerImageWorkloadReferenceEdge.cursor": + if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor == nil { break } - args, err := ec.field_Deployment_statuses_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Deployment.Statuses(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor(childComplexity), true - case "Deployment.teamSlug": - if e.ComplexityRoot.Deployment.TeamSlug == nil { + case "ContainerImageWorkloadReferenceEdge.node": + if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node == nil { break } - return e.ComplexityRoot.Deployment.TeamSlug(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node(childComplexity), true - case "Deployment.triggerUrl": - if e.ComplexityRoot.Deployment.TriggerUrl == nil { + case "CostMonthlySummary.series": + if e.ComplexityRoot.CostMonthlySummary.Series == nil { break } - return e.ComplexityRoot.Deployment.TriggerUrl(childComplexity), true + return e.ComplexityRoot.CostMonthlySummary.Series(childComplexity), true - case "DeploymentActivityLogEntry.actor": - if e.ComplexityRoot.DeploymentActivityLogEntry.Actor == nil { + case "CreateConfigPayload.config": + if e.ComplexityRoot.CreateConfigPayload.Config == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.CreateConfigPayload.Config(childComplexity), true - case "DeploymentActivityLogEntry.createdAt": - if e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt == nil { + case "CreateKafkaCredentialsPayload.credentials": + if e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials(childComplexity), true - case "DeploymentActivityLogEntry.data": - if e.ComplexityRoot.DeploymentActivityLogEntry.Data == nil { + case "CreateOpenSearchCredentialsPayload.credentials": + if e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials(childComplexity), true - case "DeploymentActivityLogEntry.environmentName": - if e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName == nil { + case "CreateOpenSearchPayload.openSearch": + if e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch(childComplexity), true - case "DeploymentActivityLogEntry.id": - if e.ComplexityRoot.DeploymentActivityLogEntry.ID == nil { + case "CreateSecretPayload.secret": + if e.ComplexityRoot.CreateSecretPayload.Secret == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.CreateSecretPayload.Secret(childComplexity), true - case "DeploymentActivityLogEntry.message": - if e.ComplexityRoot.DeploymentActivityLogEntry.Message == nil { + case "CreateServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount(childComplexity), true - case "DeploymentActivityLogEntry.resourceName": - if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName == nil { + case "CreateServiceAccountTokenPayload.secret": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret(childComplexity), true - case "DeploymentActivityLogEntry.resourceType": - if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType == nil { + case "CreateServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "DeploymentActivityLogEntry.teamSlug": - if e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug == nil { + case "CreateServiceAccountTokenPayload.serviceAccountToken": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true - case "DeploymentActivityLogEntryData.triggerURL": - if e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL == nil { + case "CreateTeamPayload.team": + if e.ComplexityRoot.CreateTeamPayload.Team == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL(childComplexity), true + return e.ComplexityRoot.CreateTeamPayload.Team(childComplexity), true - case "DeploymentConnection.edges": - if e.ComplexityRoot.DeploymentConnection.Edges == nil { + case "CreateUnleashForTeamPayload.unleash": + if e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash == nil { break } - return e.ComplexityRoot.DeploymentConnection.Edges(childComplexity), true + return e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash(childComplexity), true - case "DeploymentConnection.nodes": - if e.ComplexityRoot.DeploymentConnection.Nodes == nil { + case "CreateValkeyCredentialsPayload.credentials": + if e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.DeploymentConnection.Nodes(childComplexity), true + return e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials(childComplexity), true - case "DeploymentConnection.pageInfo": - if e.ComplexityRoot.DeploymentConnection.PageInfo == nil { + case "CreateValkeyPayload.valkey": + if e.ComplexityRoot.CreateValkeyPayload.Valkey == nil { break } - return e.ComplexityRoot.DeploymentConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.CreateValkeyPayload.Valkey(childComplexity), true - case "DeploymentEdge.cursor": - if e.ComplexityRoot.DeploymentEdge.Cursor == nil { + case "CredentialsActivityLogEntry.actor": + if e.ComplexityRoot.CredentialsActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.DeploymentEdge.Cursor(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.Actor(childComplexity), true - case "DeploymentEdge.node": - if e.ComplexityRoot.DeploymentEdge.Node == nil { + case "CredentialsActivityLogEntry.createdAt": + if e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.DeploymentEdge.Node(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt(childComplexity), true - case "DeploymentKey.created": - if e.ComplexityRoot.DeploymentKey.Created == nil { + case "CredentialsActivityLogEntry.data": + if e.ComplexityRoot.CredentialsActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.DeploymentKey.Created(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.Data(childComplexity), true - case "DeploymentKey.expires": - if e.ComplexityRoot.DeploymentKey.Expires == nil { + case "CredentialsActivityLogEntry.environmentName": + if e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.DeploymentKey.Expires(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName(childComplexity), true - case "DeploymentKey.id": - if e.ComplexityRoot.DeploymentKey.ID == nil { + case "CredentialsActivityLogEntry.id": + if e.ComplexityRoot.CredentialsActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.DeploymentKey.ID(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.ID(childComplexity), true - case "DeploymentKey.key": - if e.ComplexityRoot.DeploymentKey.Key == nil { + case "CredentialsActivityLogEntry.message": + if e.ComplexityRoot.CredentialsActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.DeploymentKey.Key(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.Message(childComplexity), true - case "DeploymentResource.id": - if e.ComplexityRoot.DeploymentResource.ID == nil { + case "CredentialsActivityLogEntry.resourceName": + if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.DeploymentResource.ID(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName(childComplexity), true - case "DeploymentResource.kind": - if e.ComplexityRoot.DeploymentResource.Kind == nil { + case "CredentialsActivityLogEntry.resourceType": + if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.DeploymentResource.Kind(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType(childComplexity), true - case "DeploymentResource.name": - if e.ComplexityRoot.DeploymentResource.Name == nil { + case "CredentialsActivityLogEntry.teamSlug": + if e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.DeploymentResource.Name(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug(childComplexity), true - case "DeploymentResourceConnection.edges": - if e.ComplexityRoot.DeploymentResourceConnection.Edges == nil { + case "CredentialsActivityLogEntryData.instanceName": + if e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.Edges(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName(childComplexity), true - case "DeploymentResourceConnection.nodes": - if e.ComplexityRoot.DeploymentResourceConnection.Nodes == nil { + case "CredentialsActivityLogEntryData.permission": + if e.ComplexityRoot.CredentialsActivityLogEntryData.Permission == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.Nodes(childComplexity), true - - case "DeploymentResourceConnection.pageInfo": - if e.ComplexityRoot.DeploymentResourceConnection.PageInfo == nil { - break - } - - return e.ComplexityRoot.DeploymentResourceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.Permission(childComplexity), true - case "DeploymentResourceEdge.cursor": - if e.ComplexityRoot.DeploymentResourceEdge.Cursor == nil { + case "CredentialsActivityLogEntryData.serviceType": + if e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType == nil { break } - return e.ComplexityRoot.DeploymentResourceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType(childComplexity), true - case "DeploymentResourceEdge.node": - if e.ComplexityRoot.DeploymentResourceEdge.Node == nil { + case "CredentialsActivityLogEntryData.ttl": + if e.ComplexityRoot.CredentialsActivityLogEntryData.TTL == nil { break } - return e.ComplexityRoot.DeploymentResourceEdge.Node(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.TTL(childComplexity), true - case "DeploymentStatus.createdAt": - if e.ComplexityRoot.DeploymentStatus.CreatedAt == nil { + case "CurrentUnitPrices.cpu": + if e.ComplexityRoot.CurrentUnitPrices.CPU == nil { break } - return e.ComplexityRoot.DeploymentStatus.CreatedAt(childComplexity), true + return e.ComplexityRoot.CurrentUnitPrices.CPU(childComplexity), true - case "DeploymentStatus.id": - if e.ComplexityRoot.DeploymentStatus.ID == nil { + case "CurrentUnitPrices.memory": + if e.ComplexityRoot.CurrentUnitPrices.Memory == nil { break } - return e.ComplexityRoot.DeploymentStatus.ID(childComplexity), true + return e.ComplexityRoot.CurrentUnitPrices.Memory(childComplexity), true - case "DeploymentStatus.message": - if e.ComplexityRoot.DeploymentStatus.Message == nil { + case "DeleteApplicationPayload.success": + if e.ComplexityRoot.DeleteApplicationPayload.Success == nil { break } - return e.ComplexityRoot.DeploymentStatus.Message(childComplexity), true + return e.ComplexityRoot.DeleteApplicationPayload.Success(childComplexity), true - case "DeploymentStatus.state": - if e.ComplexityRoot.DeploymentStatus.State == nil { + case "DeleteApplicationPayload.team": + if e.ComplexityRoot.DeleteApplicationPayload.Team == nil { break } - return e.ComplexityRoot.DeploymentStatus.State(childComplexity), true + return e.ComplexityRoot.DeleteApplicationPayload.Team(childComplexity), true - case "DeploymentStatusConnection.edges": - if e.ComplexityRoot.DeploymentStatusConnection.Edges == nil { + case "DeleteConfigPayload.configDeleted": + if e.ComplexityRoot.DeleteConfigPayload.ConfigDeleted == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.Edges(childComplexity), true + return e.ComplexityRoot.DeleteConfigPayload.ConfigDeleted(childComplexity), true - case "DeploymentStatusConnection.nodes": - if e.ComplexityRoot.DeploymentStatusConnection.Nodes == nil { + case "DeleteJobPayload.success": + if e.ComplexityRoot.DeleteJobPayload.Success == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.Nodes(childComplexity), true + return e.ComplexityRoot.DeleteJobPayload.Success(childComplexity), true - case "DeploymentStatusConnection.pageInfo": - if e.ComplexityRoot.DeploymentStatusConnection.PageInfo == nil { + case "DeleteJobPayload.team": + if e.ComplexityRoot.DeleteJobPayload.Team == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.DeleteJobPayload.Team(childComplexity), true - case "DeploymentStatusEdge.cursor": - if e.ComplexityRoot.DeploymentStatusEdge.Cursor == nil { + case "DeleteOpenSearchPayload.openSearchDeleted": + if e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted == nil { break } - return e.ComplexityRoot.DeploymentStatusEdge.Cursor(childComplexity), true + return e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted(childComplexity), true - case "DeploymentStatusEdge.node": - if e.ComplexityRoot.DeploymentStatusEdge.Node == nil { + case "DeleteSecretPayload.secretDeleted": + if e.ComplexityRoot.DeleteSecretPayload.SecretDeleted == nil { break } - return e.ComplexityRoot.DeploymentStatusEdge.Node(childComplexity), true + return e.ComplexityRoot.DeleteSecretPayload.SecretDeleted(childComplexity), true - case "DeprecatedIngressIssue.application": - if e.ComplexityRoot.DeprecatedIngressIssue.Application == nil { + case "DeleteServiceAccountPayload.serviceAccountDeleted": + if e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Application(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted(childComplexity), true - case "DeprecatedIngressIssue.id": - if e.ComplexityRoot.DeprecatedIngressIssue.ID == nil { + case "DeleteServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.ID(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "DeprecatedIngressIssue.ingresses": - if e.ComplexityRoot.DeprecatedIngressIssue.Ingresses == nil { + case "DeleteServiceAccountTokenPayload.serviceAccountTokenDeleted": + if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Ingresses(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted(childComplexity), true - case "DeprecatedIngressIssue.message": - if e.ComplexityRoot.DeprecatedIngressIssue.Message == nil { + case "DeleteUnleashInstancePayload.unleashDeleted": + if e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Message(childComplexity), true + return e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted(childComplexity), true - case "DeprecatedIngressIssue.severity": - if e.ComplexityRoot.DeprecatedIngressIssue.Severity == nil { + case "DeleteValkeyPayload.valkeyDeleted": + if e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted(childComplexity), true - case "DeprecatedIngressIssue.teamEnvironment": - if e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment == nil { + case "Deployment.commitSha": + if e.ComplexityRoot.Deployment.CommitSha == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Deployment.CommitSha(childComplexity), true - case "DeprecatedRegistryIssue.id": - if e.ComplexityRoot.DeprecatedRegistryIssue.ID == nil { + case "Deployment.createdAt": + if e.ComplexityRoot.Deployment.CreatedAt == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.ID(childComplexity), true + return e.ComplexityRoot.Deployment.CreatedAt(childComplexity), true - case "DeprecatedRegistryIssue.message": - if e.ComplexityRoot.DeprecatedRegistryIssue.Message == nil { + case "Deployment.deployerUsername": + if e.ComplexityRoot.Deployment.DeployerUsername == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Message(childComplexity), true + return e.ComplexityRoot.Deployment.DeployerUsername(childComplexity), true - case "DeprecatedRegistryIssue.severity": - if e.ComplexityRoot.DeprecatedRegistryIssue.Severity == nil { + case "Deployment.environmentName": + if e.ComplexityRoot.Deployment.EnvironmentName == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Severity(childComplexity), true + return e.ComplexityRoot.Deployment.EnvironmentName(childComplexity), true - case "DeprecatedRegistryIssue.teamEnvironment": - if e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment == nil { + case "Deployment.id": + if e.ComplexityRoot.Deployment.ID == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Deployment.ID(childComplexity), true - case "DeprecatedRegistryIssue.workload": - if e.ComplexityRoot.DeprecatedRegistryIssue.Workload == nil { + case "Deployment.repository": + if e.ComplexityRoot.Deployment.Repository == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Workload(childComplexity), true + return e.ComplexityRoot.Deployment.Repository(childComplexity), true - case "EntraIDAuthIntegration.name": - if e.ComplexityRoot.EntraIDAuthIntegration.Name == nil { + case "Deployment.resources": + if e.ComplexityRoot.Deployment.Resources == nil { break } - return e.ComplexityRoot.EntraIDAuthIntegration.Name(childComplexity), true - - case "Environment.id": - if e.ComplexityRoot.Environment.ID == nil { - break + args, err := ec.field_Deployment_resources_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Environment.ID(childComplexity), true + return e.ComplexityRoot.Deployment.Resources(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Environment.metrics": - if e.ComplexityRoot.Environment.Metrics == nil { + case "Deployment.statuses": + if e.ComplexityRoot.Deployment.Statuses == nil { break } - args, err := ec.field_Environment_metrics_args(ctx, rawArgs) + args, err := ec.field_Deployment_statuses_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Environment.Metrics(childComplexity, args["input"].(metrics.MetricsQueryInput)), true + return e.ComplexityRoot.Deployment.Statuses(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Environment.name": - if e.ComplexityRoot.Environment.Name == nil { + case "Deployment.teamSlug": + if e.ComplexityRoot.Deployment.TeamSlug == nil { break } - return e.ComplexityRoot.Environment.Name(childComplexity), true + return e.ComplexityRoot.Deployment.TeamSlug(childComplexity), true - case "Environment.workloads": - if e.ComplexityRoot.Environment.Workloads == nil { + case "Deployment.triggerUrl": + if e.ComplexityRoot.Deployment.TriggerUrl == nil { break } - args, err := ec.field_Environment_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Deployment.TriggerUrl(childComplexity), true + + case "DeploymentActivityLogEntry.actor": + if e.ComplexityRoot.DeploymentActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Environment.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.EnvironmentWorkloadOrder)), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Actor(childComplexity), true - case "EnvironmentConnection.edges": - if e.ComplexityRoot.EnvironmentConnection.Edges == nil { + case "DeploymentActivityLogEntry.createdAt": + if e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.EnvironmentConnection.Edges(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt(childComplexity), true - case "EnvironmentConnection.nodes": - if e.ComplexityRoot.EnvironmentConnection.Nodes == nil { + case "DeploymentActivityLogEntry.data": + if e.ComplexityRoot.DeploymentActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.EnvironmentConnection.Nodes(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Data(childComplexity), true - case "EnvironmentConnection.pageInfo": - if e.ComplexityRoot.EnvironmentConnection.PageInfo == nil { + case "DeploymentActivityLogEntry.environmentName": + if e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.EnvironmentConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName(childComplexity), true - case "EnvironmentEdge.cursor": - if e.ComplexityRoot.EnvironmentEdge.Cursor == nil { + case "DeploymentActivityLogEntry.id": + if e.ComplexityRoot.DeploymentActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.EnvironmentEdge.Cursor(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ID(childComplexity), true - case "EnvironmentEdge.node": - if e.ComplexityRoot.EnvironmentEdge.Node == nil { + case "DeploymentActivityLogEntry.message": + if e.ComplexityRoot.DeploymentActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.EnvironmentEdge.Node(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Message(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.cvssScore": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore == nil { + case "DeploymentActivityLogEntry.resourceName": + if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.id": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID == nil { + case "DeploymentActivityLogEntry.resourceType": + if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.ingresses": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses == nil { + case "DeploymentActivityLogEntry.teamSlug": + if e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.message": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message == nil { + case "DeploymentActivityLogEntryData.triggerURL": + if e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.severity": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity == nil { + case "DeploymentConnection.edges": + if e.ComplexityRoot.DeploymentConnection.Edges == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.Edges(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.teamEnvironment": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment == nil { + case "DeploymentConnection.nodes": + if e.ComplexityRoot.DeploymentConnection.Nodes == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.Nodes(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.workload": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload == nil { + case "DeploymentConnection.pageInfo": + if e.ComplexityRoot.DeploymentConnection.PageInfo == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.PageInfo(childComplexity), true - case "ExternalNetworkPolicyHost.ports": - if e.ComplexityRoot.ExternalNetworkPolicyHost.Ports == nil { + case "DeploymentEdge.cursor": + if e.ComplexityRoot.DeploymentEdge.Cursor == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyHost.Ports(childComplexity), true + return e.ComplexityRoot.DeploymentEdge.Cursor(childComplexity), true - case "ExternalNetworkPolicyHost.target": - if e.ComplexityRoot.ExternalNetworkPolicyHost.Target == nil { + case "DeploymentEdge.node": + if e.ComplexityRoot.DeploymentEdge.Node == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyHost.Target(childComplexity), true + return e.ComplexityRoot.DeploymentEdge.Node(childComplexity), true - case "ExternalNetworkPolicyIpv4.ports": - if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports == nil { + case "DeploymentKey.created": + if e.ComplexityRoot.DeploymentKey.Created == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Created(childComplexity), true - case "ExternalNetworkPolicyIpv4.target": - if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target == nil { + case "DeploymentKey.expires": + if e.ComplexityRoot.DeploymentKey.Expires == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Expires(childComplexity), true - case "FailedSynchronizationIssue.id": - if e.ComplexityRoot.FailedSynchronizationIssue.ID == nil { + case "DeploymentKey.id": + if e.ComplexityRoot.DeploymentKey.ID == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.ID(childComplexity), true + return e.ComplexityRoot.DeploymentKey.ID(childComplexity), true - case "FailedSynchronizationIssue.message": - if e.ComplexityRoot.FailedSynchronizationIssue.Message == nil { + case "DeploymentKey.key": + if e.ComplexityRoot.DeploymentKey.Key == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Message(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Key(childComplexity), true - case "FailedSynchronizationIssue.severity": - if e.ComplexityRoot.FailedSynchronizationIssue.Severity == nil { + case "DeploymentResource.id": + if e.ComplexityRoot.DeploymentResource.ID == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeploymentResource.ID(childComplexity), true - case "FailedSynchronizationIssue.teamEnvironment": - if e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment == nil { + case "DeploymentResource.kind": + if e.ComplexityRoot.DeploymentResource.Kind == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.DeploymentResource.Kind(childComplexity), true - case "FailedSynchronizationIssue.workload": - if e.ComplexityRoot.FailedSynchronizationIssue.Workload == nil { + case "DeploymentResource.name": + if e.ComplexityRoot.DeploymentResource.Name == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Workload(childComplexity), true + return e.ComplexityRoot.DeploymentResource.Name(childComplexity), true - case "FeatureKafka.enabled": - if e.ComplexityRoot.FeatureKafka.Enabled == nil { + case "DeploymentResourceConnection.edges": + if e.ComplexityRoot.DeploymentResourceConnection.Edges == nil { break } - return e.ComplexityRoot.FeatureKafka.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.Edges(childComplexity), true - case "FeatureKafka.id": - if e.ComplexityRoot.FeatureKafka.ID == nil { + case "DeploymentResourceConnection.nodes": + if e.ComplexityRoot.DeploymentResourceConnection.Nodes == nil { break } - return e.ComplexityRoot.FeatureKafka.ID(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.Nodes(childComplexity), true - case "FeatureOpenSearch.enabled": - if e.ComplexityRoot.FeatureOpenSearch.Enabled == nil { + case "DeploymentResourceConnection.pageInfo": + if e.ComplexityRoot.DeploymentResourceConnection.PageInfo == nil { break } - return e.ComplexityRoot.FeatureOpenSearch.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.PageInfo(childComplexity), true - case "FeatureOpenSearch.id": - if e.ComplexityRoot.FeatureOpenSearch.ID == nil { + case "DeploymentResourceEdge.cursor": + if e.ComplexityRoot.DeploymentResourceEdge.Cursor == nil { break } - return e.ComplexityRoot.FeatureOpenSearch.ID(childComplexity), true + return e.ComplexityRoot.DeploymentResourceEdge.Cursor(childComplexity), true - case "FeatureUnleash.enabled": - if e.ComplexityRoot.FeatureUnleash.Enabled == nil { + case "DeploymentResourceEdge.node": + if e.ComplexityRoot.DeploymentResourceEdge.Node == nil { break } - return e.ComplexityRoot.FeatureUnleash.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentResourceEdge.Node(childComplexity), true - case "FeatureUnleash.id": - if e.ComplexityRoot.FeatureUnleash.ID == nil { + case "DeploymentStatus.createdAt": + if e.ComplexityRoot.DeploymentStatus.CreatedAt == nil { break } - return e.ComplexityRoot.FeatureUnleash.ID(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.CreatedAt(childComplexity), true - case "FeatureValkey.enabled": - if e.ComplexityRoot.FeatureValkey.Enabled == nil { + case "DeploymentStatus.id": + if e.ComplexityRoot.DeploymentStatus.ID == nil { break } - return e.ComplexityRoot.FeatureValkey.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.ID(childComplexity), true - case "FeatureValkey.id": - if e.ComplexityRoot.FeatureValkey.ID == nil { + case "DeploymentStatus.message": + if e.ComplexityRoot.DeploymentStatus.Message == nil { break } - return e.ComplexityRoot.FeatureValkey.ID(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.Message(childComplexity), true - case "Features.id": - if e.ComplexityRoot.Features.ID == nil { + case "DeploymentStatus.state": + if e.ComplexityRoot.DeploymentStatus.State == nil { break } - return e.ComplexityRoot.Features.ID(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.State(childComplexity), true - case "Features.kafka": - if e.ComplexityRoot.Features.Kafka == nil { + case "DeploymentStatusConnection.edges": + if e.ComplexityRoot.DeploymentStatusConnection.Edges == nil { break } - return e.ComplexityRoot.Features.Kafka(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.Edges(childComplexity), true - case "Features.openSearch": - if e.ComplexityRoot.Features.OpenSearch == nil { + case "DeploymentStatusConnection.nodes": + if e.ComplexityRoot.DeploymentStatusConnection.Nodes == nil { break } - return e.ComplexityRoot.Features.OpenSearch(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.Nodes(childComplexity), true - case "Features.unleash": - if e.ComplexityRoot.Features.Unleash == nil { + case "DeploymentStatusConnection.pageInfo": + if e.ComplexityRoot.DeploymentStatusConnection.PageInfo == nil { break } - return e.ComplexityRoot.Features.Unleash(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.PageInfo(childComplexity), true - case "Features.valkey": - if e.ComplexityRoot.Features.Valkey == nil { + case "DeploymentStatusEdge.cursor": + if e.ComplexityRoot.DeploymentStatusEdge.Cursor == nil { break } - return e.ComplexityRoot.Features.Valkey(childComplexity), true + return e.ComplexityRoot.DeploymentStatusEdge.Cursor(childComplexity), true - case "GrantPostgresAccessPayload.error": - if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { + case "DeploymentStatusEdge.node": + if e.ComplexityRoot.DeploymentStatusEdge.Node == nil { break } - return e.ComplexityRoot.GrantPostgresAccessPayload.Error(childComplexity), true + return e.ComplexityRoot.DeploymentStatusEdge.Node(childComplexity), true - case "IDPortenAuthIntegration.name": - if e.ComplexityRoot.IDPortenAuthIntegration.Name == nil { + case "DeprecatedIngressIssue.application": + if e.ComplexityRoot.DeprecatedIngressIssue.Application == nil { break } - return e.ComplexityRoot.IDPortenAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Application(childComplexity), true - case "ImageVulnerability.cvssScore": - if e.ComplexityRoot.ImageVulnerability.CvssScore == nil { + case "DeprecatedIngressIssue.id": + if e.ComplexityRoot.DeprecatedIngressIssue.ID == nil { break } - return e.ComplexityRoot.ImageVulnerability.CvssScore(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.ID(childComplexity), true - case "ImageVulnerability.description": - if e.ComplexityRoot.ImageVulnerability.Description == nil { + case "DeprecatedIngressIssue.ingresses": + if e.ComplexityRoot.DeprecatedIngressIssue.Ingresses == nil { break } - return e.ComplexityRoot.ImageVulnerability.Description(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Ingresses(childComplexity), true - case "ImageVulnerability.id": - if e.ComplexityRoot.ImageVulnerability.ID == nil { + case "DeprecatedIngressIssue.message": + if e.ComplexityRoot.DeprecatedIngressIssue.Message == nil { break } - return e.ComplexityRoot.ImageVulnerability.ID(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Message(childComplexity), true - case "ImageVulnerability.identifier": - if e.ComplexityRoot.ImageVulnerability.Identifier == nil { + case "DeprecatedIngressIssue.severity": + if e.ComplexityRoot.DeprecatedIngressIssue.Severity == nil { break } - return e.ComplexityRoot.ImageVulnerability.Identifier(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Severity(childComplexity), true - case "ImageVulnerability.package": - if e.ComplexityRoot.ImageVulnerability.Package == nil { + case "DeprecatedIngressIssue.teamEnvironment": + if e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.ImageVulnerability.Package(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment(childComplexity), true - case "ImageVulnerability.severity": - if e.ComplexityRoot.ImageVulnerability.Severity == nil { + case "DeprecatedRegistryIssue.id": + if e.ComplexityRoot.DeprecatedRegistryIssue.ID == nil { break } - return e.ComplexityRoot.ImageVulnerability.Severity(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.ID(childComplexity), true - case "ImageVulnerability.severitySince": - if e.ComplexityRoot.ImageVulnerability.SeveritySince == nil { + case "DeprecatedRegistryIssue.message": + if e.ComplexityRoot.DeprecatedRegistryIssue.Message == nil { break } - return e.ComplexityRoot.ImageVulnerability.SeveritySince(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Message(childComplexity), true - case "ImageVulnerability.suppression": - if e.ComplexityRoot.ImageVulnerability.Suppression == nil { + case "DeprecatedRegistryIssue.severity": + if e.ComplexityRoot.DeprecatedRegistryIssue.Severity == nil { break } - return e.ComplexityRoot.ImageVulnerability.Suppression(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Severity(childComplexity), true - case "ImageVulnerability.vulnerabilityDetailsLink": - if e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink == nil { + case "DeprecatedRegistryIssue.teamEnvironment": + if e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment(childComplexity), true - case "ImageVulnerabilityConnection.edges": - if e.ComplexityRoot.ImageVulnerabilityConnection.Edges == nil { + case "DeprecatedRegistryIssue.workload": + if e.ComplexityRoot.DeprecatedRegistryIssue.Workload == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.Edges(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Workload(childComplexity), true - case "ImageVulnerabilityConnection.nodes": - if e.ComplexityRoot.ImageVulnerabilityConnection.Nodes == nil { + case "EntraIDAuthIntegration.name": + if e.ComplexityRoot.EntraIDAuthIntegration.Name == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.Nodes(childComplexity), true + return e.ComplexityRoot.EntraIDAuthIntegration.Name(childComplexity), true - case "ImageVulnerabilityConnection.pageInfo": - if e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo == nil { + case "Environment.id": + if e.ComplexityRoot.Environment.ID == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Environment.ID(childComplexity), true - case "ImageVulnerabilityEdge.cursor": - if e.ComplexityRoot.ImageVulnerabilityEdge.Cursor == nil { + case "Environment.metrics": + if e.ComplexityRoot.Environment.Metrics == nil { break } - return e.ComplexityRoot.ImageVulnerabilityEdge.Cursor(childComplexity), true - - case "ImageVulnerabilityEdge.node": - if e.ComplexityRoot.ImageVulnerabilityEdge.Node == nil { - break + args, err := ec.field_Environment_metrics_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerabilityEdge.Node(childComplexity), true + return e.ComplexityRoot.Environment.Metrics(childComplexity, args["input"].(metrics.MetricsQueryInput)), true - case "ImageVulnerabilityHistory.samples": - if e.ComplexityRoot.ImageVulnerabilityHistory.Samples == nil { + case "Environment.name": + if e.ComplexityRoot.Environment.Name == nil { break } - return e.ComplexityRoot.ImageVulnerabilityHistory.Samples(childComplexity), true + return e.ComplexityRoot.Environment.Name(childComplexity), true - case "ImageVulnerabilitySample.date": - if e.ComplexityRoot.ImageVulnerabilitySample.Date == nil { + case "Environment.workloads": + if e.ComplexityRoot.Environment.Workloads == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySample.Date(childComplexity), true - - case "ImageVulnerabilitySample.summary": - if e.ComplexityRoot.ImageVulnerabilitySample.Summary == nil { - break + args, err := ec.field_Environment_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerabilitySample.Summary(childComplexity), true + return e.ComplexityRoot.Environment.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.EnvironmentWorkloadOrder)), true - case "ImageVulnerabilitySummary.critical": - if e.ComplexityRoot.ImageVulnerabilitySummary.Critical == nil { + case "EnvironmentConnection.edges": + if e.ComplexityRoot.EnvironmentConnection.Edges == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Critical(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.Edges(childComplexity), true - case "ImageVulnerabilitySummary.high": - if e.ComplexityRoot.ImageVulnerabilitySummary.High == nil { + case "EnvironmentConnection.nodes": + if e.ComplexityRoot.EnvironmentConnection.Nodes == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.Nodes(childComplexity), true - case "ImageVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated == nil { + case "EnvironmentConnection.pageInfo": + if e.ComplexityRoot.EnvironmentConnection.PageInfo == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.PageInfo(childComplexity), true - case "ImageVulnerabilitySummary.low": - if e.ComplexityRoot.ImageVulnerabilitySummary.Low == nil { + case "EnvironmentEdge.cursor": + if e.ComplexityRoot.EnvironmentEdge.Cursor == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.EnvironmentEdge.Cursor(childComplexity), true - case "ImageVulnerabilitySummary.medium": - if e.ComplexityRoot.ImageVulnerabilitySummary.Medium == nil { + case "EnvironmentEdge.node": + if e.ComplexityRoot.EnvironmentEdge.Node == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.EnvironmentEdge.Node(childComplexity), true - case "ImageVulnerabilitySummary.riskScore": - if e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore == nil { + case "ExternalIngressCriticalVulnerabilityIssue.cvssScore": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore(childComplexity), true - case "ImageVulnerabilitySummary.total": - if e.ComplexityRoot.ImageVulnerabilitySummary.Total == nil { + case "ExternalIngressCriticalVulnerabilityIssue.id": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Total(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID(childComplexity), true - case "ImageVulnerabilitySummary.unassigned": - if e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned == nil { + case "ExternalIngressCriticalVulnerabilityIssue.ingresses": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses(childComplexity), true - case "ImageVulnerabilitySuppression.reason": - if e.ComplexityRoot.ImageVulnerabilitySuppression.Reason == nil { + case "ExternalIngressCriticalVulnerabilityIssue.message": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySuppression.Reason(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message(childComplexity), true - case "ImageVulnerabilitySuppression.state": - if e.ComplexityRoot.ImageVulnerabilitySuppression.State == nil { + case "ExternalIngressCriticalVulnerabilityIssue.severity": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySuppression.State(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity(childComplexity), true - case "InboundNetworkPolicy.rules": - if e.ComplexityRoot.InboundNetworkPolicy.Rules == nil { + case "ExternalIngressCriticalVulnerabilityIssue.teamEnvironment": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.InboundNetworkPolicy.Rules(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment(childComplexity), true - case "Ingress.metrics": - if e.ComplexityRoot.Ingress.Metrics == nil { + case "ExternalIngressCriticalVulnerabilityIssue.workload": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload == nil { break } - return e.ComplexityRoot.Ingress.Metrics(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload(childComplexity), true - case "Ingress.type": - if e.ComplexityRoot.Ingress.Type == nil { + case "ExternalNetworkPolicyHost.ports": + if e.ComplexityRoot.ExternalNetworkPolicyHost.Ports == nil { break } - return e.ComplexityRoot.Ingress.Type(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyHost.Ports(childComplexity), true - case "Ingress.url": - if e.ComplexityRoot.Ingress.URL == nil { + case "ExternalNetworkPolicyHost.target": + if e.ComplexityRoot.ExternalNetworkPolicyHost.Target == nil { break } - return e.ComplexityRoot.Ingress.URL(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyHost.Target(childComplexity), true - case "IngressMetricSample.timestamp": - if e.ComplexityRoot.IngressMetricSample.Timestamp == nil { + case "ExternalNetworkPolicyIpv4.ports": + if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports == nil { break } - return e.ComplexityRoot.IngressMetricSample.Timestamp(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports(childComplexity), true - case "IngressMetricSample.value": - if e.ComplexityRoot.IngressMetricSample.Value == nil { + case "ExternalNetworkPolicyIpv4.target": + if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target == nil { break } - return e.ComplexityRoot.IngressMetricSample.Value(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target(childComplexity), true - case "IngressMetrics.errorsPerSecond": - if e.ComplexityRoot.IngressMetrics.ErrorsPerSecond == nil { + case "FailedSynchronizationIssue.id": + if e.ComplexityRoot.FailedSynchronizationIssue.ID == nil { break } - return e.ComplexityRoot.IngressMetrics.ErrorsPerSecond(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.ID(childComplexity), true - case "IngressMetrics.requestsPerSecond": - if e.ComplexityRoot.IngressMetrics.RequestsPerSecond == nil { + case "FailedSynchronizationIssue.message": + if e.ComplexityRoot.FailedSynchronizationIssue.Message == nil { break } - return e.ComplexityRoot.IngressMetrics.RequestsPerSecond(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Message(childComplexity), true - case "IngressMetrics.series": - if e.ComplexityRoot.IngressMetrics.Series == nil { + case "FailedSynchronizationIssue.severity": + if e.ComplexityRoot.FailedSynchronizationIssue.Severity == nil { break } - args, err := ec.field_IngressMetrics_series_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.IngressMetrics.Series(childComplexity, args["input"].(application.IngressMetricsInput)), true + return e.ComplexityRoot.FailedSynchronizationIssue.Severity(childComplexity), true - case "InvalidSpecIssue.id": - if e.ComplexityRoot.InvalidSpecIssue.ID == nil { + case "FailedSynchronizationIssue.teamEnvironment": + if e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.ID(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment(childComplexity), true - case "InvalidSpecIssue.message": - if e.ComplexityRoot.InvalidSpecIssue.Message == nil { + case "FailedSynchronizationIssue.workload": + if e.ComplexityRoot.FailedSynchronizationIssue.Workload == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Message(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Workload(childComplexity), true - case "InvalidSpecIssue.severity": - if e.ComplexityRoot.InvalidSpecIssue.Severity == nil { + case "FeatureKafka.enabled": + if e.ComplexityRoot.FeatureKafka.Enabled == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Severity(childComplexity), true + return e.ComplexityRoot.FeatureKafka.Enabled(childComplexity), true - case "InvalidSpecIssue.teamEnvironment": - if e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment == nil { + case "FeatureKafka.id": + if e.ComplexityRoot.FeatureKafka.ID == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.FeatureKafka.ID(childComplexity), true - case "InvalidSpecIssue.workload": - if e.ComplexityRoot.InvalidSpecIssue.Workload == nil { + case "FeatureOpenSearch.enabled": + if e.ComplexityRoot.FeatureOpenSearch.Enabled == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Workload(childComplexity), true + return e.ComplexityRoot.FeatureOpenSearch.Enabled(childComplexity), true - case "IssueConnection.edges": - if e.ComplexityRoot.IssueConnection.Edges == nil { + case "FeatureOpenSearch.id": + if e.ComplexityRoot.FeatureOpenSearch.ID == nil { break } - return e.ComplexityRoot.IssueConnection.Edges(childComplexity), true + return e.ComplexityRoot.FeatureOpenSearch.ID(childComplexity), true - case "IssueConnection.nodes": - if e.ComplexityRoot.IssueConnection.Nodes == nil { + case "FeatureUnleash.enabled": + if e.ComplexityRoot.FeatureUnleash.Enabled == nil { break } - return e.ComplexityRoot.IssueConnection.Nodes(childComplexity), true + return e.ComplexityRoot.FeatureUnleash.Enabled(childComplexity), true - case "IssueConnection.pageInfo": - if e.ComplexityRoot.IssueConnection.PageInfo == nil { + case "FeatureUnleash.id": + if e.ComplexityRoot.FeatureUnleash.ID == nil { break } - return e.ComplexityRoot.IssueConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.FeatureUnleash.ID(childComplexity), true - case "IssueEdge.cursor": - if e.ComplexityRoot.IssueEdge.Cursor == nil { + case "FeatureValkey.enabled": + if e.ComplexityRoot.FeatureValkey.Enabled == nil { break } - return e.ComplexityRoot.IssueEdge.Cursor(childComplexity), true + return e.ComplexityRoot.FeatureValkey.Enabled(childComplexity), true - case "IssueEdge.node": - if e.ComplexityRoot.IssueEdge.Node == nil { + case "FeatureValkey.id": + if e.ComplexityRoot.FeatureValkey.ID == nil { break } - return e.ComplexityRoot.IssueEdge.Node(childComplexity), true + return e.ComplexityRoot.FeatureValkey.ID(childComplexity), true - case "Job.activityLog": - if e.ComplexityRoot.Job.ActivityLog == nil { + case "Features.id": + if e.ComplexityRoot.Features.ID == nil { break } - args, err := ec.field_Job_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Features.ID(childComplexity), true - case "Job.authIntegrations": - if e.ComplexityRoot.Job.AuthIntegrations == nil { + case "Features.kafka": + if e.ComplexityRoot.Features.Kafka == nil { break } - return e.ComplexityRoot.Job.AuthIntegrations(childComplexity), true + return e.ComplexityRoot.Features.Kafka(childComplexity), true - case "Job.bigQueryDatasets": - if e.ComplexityRoot.Job.BigQueryDatasets == nil { + case "Features.openSearch": + if e.ComplexityRoot.Features.OpenSearch == nil { break } - args, err := ec.field_Job_bigQueryDatasets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.BigQueryDatasets(childComplexity, args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true + return e.ComplexityRoot.Features.OpenSearch(childComplexity), true - case "Job.buckets": - if e.ComplexityRoot.Job.Buckets == nil { + case "Features.unleash": + if e.ComplexityRoot.Features.Unleash == nil { break } - args, err := ec.field_Job_buckets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true + return e.ComplexityRoot.Features.Unleash(childComplexity), true - case "Job.cost": - if e.ComplexityRoot.Job.Cost == nil { + case "Features.valkey": + if e.ComplexityRoot.Features.Valkey == nil { break } - return e.ComplexityRoot.Job.Cost(childComplexity), true + return e.ComplexityRoot.Features.Valkey(childComplexity), true - case "Job.deletionStartedAt": - if e.ComplexityRoot.Job.DeletionStartedAt == nil { + case "GrantPostgresAccessPayload.error": + if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { break } - return e.ComplexityRoot.Job.DeletionStartedAt(childComplexity), true + return e.ComplexityRoot.GrantPostgresAccessPayload.Error(childComplexity), true - case "Job.deployments": - if e.ComplexityRoot.Job.Deployments == nil { + case "IDPortenAuthIntegration.name": + if e.ComplexityRoot.IDPortenAuthIntegration.Name == nil { break } - args, err := ec.field_Job_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.IDPortenAuthIntegration.Name(childComplexity), true + + case "ImageVulnerability.cvssScore": + if e.ComplexityRoot.ImageVulnerability.CvssScore == nil { + break } - return e.ComplexityRoot.Job.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ImageVulnerability.CvssScore(childComplexity), true - case "Job.environment": - if e.ComplexityRoot.Job.Environment == nil { + case "ImageVulnerability.description": + if e.ComplexityRoot.ImageVulnerability.Description == nil { break } - return e.ComplexityRoot.Job.Environment(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Description(childComplexity), true - case "Job.id": - if e.ComplexityRoot.Job.ID == nil { + case "ImageVulnerability.id": + if e.ComplexityRoot.ImageVulnerability.ID == nil { break } - return e.ComplexityRoot.Job.ID(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.ID(childComplexity), true - case "Job.image": - if e.ComplexityRoot.Job.Image == nil { + case "ImageVulnerability.identifier": + if e.ComplexityRoot.ImageVulnerability.Identifier == nil { break } - return e.ComplexityRoot.Job.Image(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Identifier(childComplexity), true - case "Job.imageVulnerabilityHistory": - if e.ComplexityRoot.Job.ImageVulnerabilityHistory == nil { + case "ImageVulnerability.package": + if e.ComplexityRoot.ImageVulnerability.Package == nil { break } - args, err := ec.field_Job_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.ImageVulnerability.Package(childComplexity), true - case "Job.issues": - if e.ComplexityRoot.Job.Issues == nil { + case "ImageVulnerability.severity": + if e.ComplexityRoot.ImageVulnerability.Severity == nil { break } - args, err := ec.field_Job_issues_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.ImageVulnerability.Severity(childComplexity), true - case "Job.kafkaTopicAcls": - if e.ComplexityRoot.Job.KafkaTopicAcls == nil { + case "ImageVulnerability.severitySince": + if e.ComplexityRoot.ImageVulnerability.SeveritySince == nil { break } - args, err := ec.field_Job_kafkaTopicAcls_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.KafkaTopicAcls(childComplexity, args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true + return e.ComplexityRoot.ImageVulnerability.SeveritySince(childComplexity), true - case "Job.logDestinations": - if e.ComplexityRoot.Job.LogDestinations == nil { + case "ImageVulnerability.suppression": + if e.ComplexityRoot.ImageVulnerability.Suppression == nil { break } - return e.ComplexityRoot.Job.LogDestinations(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Suppression(childComplexity), true - case "Job.manifest": - if e.ComplexityRoot.Job.Manifest == nil { + case "ImageVulnerability.vulnerabilityDetailsLink": + if e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink == nil { break } - return e.ComplexityRoot.Job.Manifest(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink(childComplexity), true - case "Job.name": - if e.ComplexityRoot.Job.Name == nil { + case "ImageVulnerabilityConnection.edges": + if e.ComplexityRoot.ImageVulnerabilityConnection.Edges == nil { break } - return e.ComplexityRoot.Job.Name(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.Edges(childComplexity), true - case "Job.networkPolicy": - if e.ComplexityRoot.Job.NetworkPolicy == nil { + case "ImageVulnerabilityConnection.nodes": + if e.ComplexityRoot.ImageVulnerabilityConnection.Nodes == nil { break } - return e.ComplexityRoot.Job.NetworkPolicy(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.Nodes(childComplexity), true - case "Job.openSearch": - if e.ComplexityRoot.Job.OpenSearch == nil { + case "ImageVulnerabilityConnection.pageInfo": + if e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo == nil { break } - return e.ComplexityRoot.Job.OpenSearch(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo(childComplexity), true - case "Job.postgresInstances": - if e.ComplexityRoot.Job.PostgresInstances == nil { + case "ImageVulnerabilityEdge.cursor": + if e.ComplexityRoot.ImageVulnerabilityEdge.Cursor == nil { break } - args, err := ec.field_Job_postgresInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.PostgresInstances(childComplexity, args["orderBy"].(*postgres.PostgresInstanceOrder)), true + return e.ComplexityRoot.ImageVulnerabilityEdge.Cursor(childComplexity), true - case "Job.resources": - if e.ComplexityRoot.Job.Resources == nil { + case "ImageVulnerabilityEdge.node": + if e.ComplexityRoot.ImageVulnerabilityEdge.Node == nil { break } - return e.ComplexityRoot.Job.Resources(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityEdge.Node(childComplexity), true - case "Job.runs": - if e.ComplexityRoot.Job.Runs == nil { + case "ImageVulnerabilityHistory.samples": + if e.ComplexityRoot.ImageVulnerabilityHistory.Samples == nil { break } - args, err := ec.field_Job_runs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Runs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ImageVulnerabilityHistory.Samples(childComplexity), true - case "Job.sqlInstances": - if e.ComplexityRoot.Job.SQLInstances == nil { + case "ImageVulnerabilitySample.date": + if e.ComplexityRoot.ImageVulnerabilitySample.Date == nil { break } - args, err := ec.field_Job_sqlInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.SQLInstances(childComplexity, args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + return e.ComplexityRoot.ImageVulnerabilitySample.Date(childComplexity), true - case "Job.schedule": - if e.ComplexityRoot.Job.Schedule == nil { + case "ImageVulnerabilitySample.summary": + if e.ComplexityRoot.ImageVulnerabilitySample.Summary == nil { break } - return e.ComplexityRoot.Job.Schedule(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySample.Summary(childComplexity), true - case "Job.secrets": - if e.ComplexityRoot.Job.Secrets == nil { + case "ImageVulnerabilitySummary.critical": + if e.ComplexityRoot.ImageVulnerabilitySummary.Critical == nil { break } - args, err := ec.field_Job_secrets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Critical(childComplexity), true - case "Job.state": - if e.ComplexityRoot.Job.State == nil { + case "ImageVulnerabilitySummary.high": + if e.ComplexityRoot.ImageVulnerabilitySummary.High == nil { break } - return e.ComplexityRoot.Job.State(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.High(childComplexity), true - case "Job.team": - if e.ComplexityRoot.Job.Team == nil { + case "ImageVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.Job.Team(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated(childComplexity), true - case "Job.teamEnvironment": - if e.ComplexityRoot.Job.TeamEnvironment == nil { + case "ImageVulnerabilitySummary.low": + if e.ComplexityRoot.ImageVulnerabilitySummary.Low == nil { break } - return e.ComplexityRoot.Job.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Low(childComplexity), true - case "Job.valkeys": - if e.ComplexityRoot.Job.Valkeys == nil { + case "ImageVulnerabilitySummary.medium": + if e.ComplexityRoot.ImageVulnerabilitySummary.Medium == nil { break } - args, err := ec.field_Job_valkeys_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Valkeys(childComplexity, args["orderBy"].(*valkey.ValkeyOrder)), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Medium(childComplexity), true - case "Job.vulnerabilityFixHistory": - if e.ComplexityRoot.Job.VulnerabilityFixHistory == nil { + case "ImageVulnerabilitySummary.riskScore": + if e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore == nil { break } - args, err := ec.field_Job_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore(childComplexity), true - case "JobConnection.edges": - if e.ComplexityRoot.JobConnection.Edges == nil { + case "ImageVulnerabilitySummary.total": + if e.ComplexityRoot.ImageVulnerabilitySummary.Total == nil { break } - return e.ComplexityRoot.JobConnection.Edges(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Total(childComplexity), true - case "JobConnection.nodes": - if e.ComplexityRoot.JobConnection.Nodes == nil { + case "ImageVulnerabilitySummary.unassigned": + if e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.JobConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned(childComplexity), true - case "JobConnection.pageInfo": - if e.ComplexityRoot.JobConnection.PageInfo == nil { + case "ImageVulnerabilitySuppression.reason": + if e.ComplexityRoot.ImageVulnerabilitySuppression.Reason == nil { break } - return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySuppression.Reason(childComplexity), true - case "JobDeletedActivityLogEntry.actor": - if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { + case "ImageVulnerabilitySuppression.state": + if e.ComplexityRoot.ImageVulnerabilitySuppression.State == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySuppression.State(childComplexity), true - case "JobDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt == nil { + case "InboundNetworkPolicy.rules": + if e.ComplexityRoot.InboundNetworkPolicy.Rules == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.InboundNetworkPolicy.Rules(childComplexity), true - case "JobDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName == nil { + case "Ingress.metrics": + if e.ComplexityRoot.Ingress.Metrics == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Ingress.Metrics(childComplexity), true - case "JobDeletedActivityLogEntry.id": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ID == nil { + case "Ingress.type": + if e.ComplexityRoot.Ingress.Type == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Ingress.Type(childComplexity), true - case "JobDeletedActivityLogEntry.message": - if e.ComplexityRoot.JobDeletedActivityLogEntry.Message == nil { + case "Ingress.url": + if e.ComplexityRoot.Ingress.URL == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Ingress.URL(childComplexity), true - case "JobDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName == nil { + case "IngressMetricSample.timestamp": + if e.ComplexityRoot.IngressMetricSample.Timestamp == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.IngressMetricSample.Timestamp(childComplexity), true - case "JobDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType == nil { + case "IngressMetricSample.value": + if e.ComplexityRoot.IngressMetricSample.Value == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.IngressMetricSample.Value(childComplexity), true - case "JobDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug == nil { + case "IngressMetrics.errorsPerSecond": + if e.ComplexityRoot.IngressMetrics.ErrorsPerSecond == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.IngressMetrics.ErrorsPerSecond(childComplexity), true - case "JobEdge.cursor": - if e.ComplexityRoot.JobEdge.Cursor == nil { + case "IngressMetrics.requestsPerSecond": + if e.ComplexityRoot.IngressMetrics.RequestsPerSecond == nil { break } - return e.ComplexityRoot.JobEdge.Cursor(childComplexity), true + return e.ComplexityRoot.IngressMetrics.RequestsPerSecond(childComplexity), true - case "JobEdge.node": - if e.ComplexityRoot.JobEdge.Node == nil { + case "IngressMetrics.series": + if e.ComplexityRoot.IngressMetrics.Series == nil { break } - return e.ComplexityRoot.JobEdge.Node(childComplexity), true + args, err := ec.field_IngressMetrics_series_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "JobManifest.content": - if e.ComplexityRoot.JobManifest.Content == nil { + return e.ComplexityRoot.IngressMetrics.Series(childComplexity, args["input"].(application.IngressMetricsInput)), true + + case "InvalidSpecIssue.id": + if e.ComplexityRoot.InvalidSpecIssue.ID == nil { break } - return e.ComplexityRoot.JobManifest.Content(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.ID(childComplexity), true - case "JobResources.limits": - if e.ComplexityRoot.JobResources.Limits == nil { + case "InvalidSpecIssue.message": + if e.ComplexityRoot.InvalidSpecIssue.Message == nil { break } - return e.ComplexityRoot.JobResources.Limits(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Message(childComplexity), true - case "JobResources.requests": - if e.ComplexityRoot.JobResources.Requests == nil { + case "InvalidSpecIssue.severity": + if e.ComplexityRoot.InvalidSpecIssue.Severity == nil { break } - return e.ComplexityRoot.JobResources.Requests(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Severity(childComplexity), true - case "JobRun.completionTime": - if e.ComplexityRoot.JobRun.CompletionTime == nil { + case "InvalidSpecIssue.teamEnvironment": + if e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.JobRun.CompletionTime(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment(childComplexity), true - case "JobRun.duration": - if e.ComplexityRoot.JobRun.Duration == nil { + case "InvalidSpecIssue.workload": + if e.ComplexityRoot.InvalidSpecIssue.Workload == nil { break } - return e.ComplexityRoot.JobRun.Duration(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Workload(childComplexity), true - case "JobRun.id": - if e.ComplexityRoot.JobRun.ID == nil { + case "IssueConnection.edges": + if e.ComplexityRoot.IssueConnection.Edges == nil { break } - return e.ComplexityRoot.JobRun.ID(childComplexity), true + return e.ComplexityRoot.IssueConnection.Edges(childComplexity), true - case "JobRun.image": - if e.ComplexityRoot.JobRun.Image == nil { + case "IssueConnection.nodes": + if e.ComplexityRoot.IssueConnection.Nodes == nil { break } - return e.ComplexityRoot.JobRun.Image(childComplexity), true + return e.ComplexityRoot.IssueConnection.Nodes(childComplexity), true - case "JobRun.instances": - if e.ComplexityRoot.JobRun.Instances == nil { + case "IssueConnection.pageInfo": + if e.ComplexityRoot.IssueConnection.PageInfo == nil { break } - args, err := ec.field_JobRun_instances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.JobRun.Instances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.IssueConnection.PageInfo(childComplexity), true - case "JobRun.name": - if e.ComplexityRoot.JobRun.Name == nil { + case "IssueEdge.cursor": + if e.ComplexityRoot.IssueEdge.Cursor == nil { break } - return e.ComplexityRoot.JobRun.Name(childComplexity), true + return e.ComplexityRoot.IssueEdge.Cursor(childComplexity), true - case "JobRun.startTime": - if e.ComplexityRoot.JobRun.StartTime == nil { + case "IssueEdge.node": + if e.ComplexityRoot.IssueEdge.Node == nil { break } - return e.ComplexityRoot.JobRun.StartTime(childComplexity), true + return e.ComplexityRoot.IssueEdge.Node(childComplexity), true - case "JobRun.status": - if e.ComplexityRoot.JobRun.Status == nil { + case "Job.activityLog": + if e.ComplexityRoot.Job.ActivityLog == nil { break } - return e.ComplexityRoot.JobRun.Status(childComplexity), true - - case "JobRun.trigger": - if e.ComplexityRoot.JobRun.Trigger == nil { - break + args, err := ec.field_Job_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRun.Trigger(childComplexity), true + return e.ComplexityRoot.Job.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "JobRunConnection.edges": - if e.ComplexityRoot.JobRunConnection.Edges == nil { + case "Job.authIntegrations": + if e.ComplexityRoot.Job.AuthIntegrations == nil { break } - return e.ComplexityRoot.JobRunConnection.Edges(childComplexity), true + return e.ComplexityRoot.Job.AuthIntegrations(childComplexity), true - case "JobRunConnection.nodes": - if e.ComplexityRoot.JobRunConnection.Nodes == nil { + case "Job.bigQueryDatasets": + if e.ComplexityRoot.Job.BigQueryDatasets == nil { break } - return e.ComplexityRoot.JobRunConnection.Nodes(childComplexity), true - - case "JobRunConnection.pageInfo": - if e.ComplexityRoot.JobRunConnection.PageInfo == nil { - break + args, err := ec.field_Job_bigQueryDatasets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Job.BigQueryDatasets(childComplexity, args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - case "JobRunEdge.cursor": - if e.ComplexityRoot.JobRunEdge.Cursor == nil { + case "Job.buckets": + if e.ComplexityRoot.Job.Buckets == nil { break } - return e.ComplexityRoot.JobRunEdge.Cursor(childComplexity), true - - case "JobRunEdge.node": - if e.ComplexityRoot.JobRunEdge.Node == nil { - break + args, err := ec.field_Job_buckets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunEdge.Node(childComplexity), true + return e.ComplexityRoot.Job.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true - case "JobRunInstance.id": - if e.ComplexityRoot.JobRunInstance.ID == nil { + case "Job.configs": + if e.ComplexityRoot.Job.Configs == nil { break } - return e.ComplexityRoot.JobRunInstance.ID(childComplexity), true - - case "JobRunInstance.name": - if e.ComplexityRoot.JobRunInstance.Name == nil { - break + args, err := ec.field_Job_configs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunInstance.Name(childComplexity), true + return e.ComplexityRoot.Job.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "JobRunInstanceConnection.edges": - if e.ComplexityRoot.JobRunInstanceConnection.Edges == nil { + case "Job.cost": + if e.ComplexityRoot.Job.Cost == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.Job.Cost(childComplexity), true - case "JobRunInstanceConnection.nodes": - if e.ComplexityRoot.JobRunInstanceConnection.Nodes == nil { + case "Job.deletionStartedAt": + if e.ComplexityRoot.Job.DeletionStartedAt == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Job.DeletionStartedAt(childComplexity), true - case "JobRunInstanceConnection.pageInfo": - if e.ComplexityRoot.JobRunInstanceConnection.PageInfo == nil { + case "Job.deployments": + if e.ComplexityRoot.Job.Deployments == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.PageInfo(childComplexity), true - - case "JobRunInstanceEdge.cursor": - if e.ComplexityRoot.JobRunInstanceEdge.Cursor == nil { - break + args, err := ec.field_Job_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Job.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "JobRunInstanceEdge.node": - if e.ComplexityRoot.JobRunInstanceEdge.Node == nil { + case "Job.environment": + if e.ComplexityRoot.Job.Environment == nil { break } - return e.ComplexityRoot.JobRunInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.Job.Environment(childComplexity), true - case "JobRunStatus.message": - if e.ComplexityRoot.JobRunStatus.Message == nil { + case "Job.id": + if e.ComplexityRoot.Job.ID == nil { break } - return e.ComplexityRoot.JobRunStatus.Message(childComplexity), true + return e.ComplexityRoot.Job.ID(childComplexity), true - case "JobRunStatus.state": - if e.ComplexityRoot.JobRunStatus.State == nil { + case "Job.image": + if e.ComplexityRoot.Job.Image == nil { break } - return e.ComplexityRoot.JobRunStatus.State(childComplexity), true + return e.ComplexityRoot.Job.Image(childComplexity), true - case "JobRunTrigger.actor": - if e.ComplexityRoot.JobRunTrigger.Actor == nil { + case "Job.imageVulnerabilityHistory": + if e.ComplexityRoot.Job.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.JobRunTrigger.Actor(childComplexity), true - - case "JobRunTrigger.type": - if e.ComplexityRoot.JobRunTrigger.Type == nil { - break + args, err := ec.field_Job_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunTrigger.Type(childComplexity), true + return e.ComplexityRoot.Job.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true - case "JobSchedule.expression": - if e.ComplexityRoot.JobSchedule.Expression == nil { + case "Job.issues": + if e.ComplexityRoot.Job.Issues == nil { break } - return e.ComplexityRoot.JobSchedule.Expression(childComplexity), true - - case "JobSchedule.timeZone": - if e.ComplexityRoot.JobSchedule.TimeZone == nil { - break + args, err := ec.field_Job_issues_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobSchedule.TimeZone(childComplexity), true + return e.ComplexityRoot.Job.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "JobTriggeredActivityLogEntry.actor": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor == nil { + case "Job.kafkaTopicAcls": + if e.ComplexityRoot.Job.KafkaTopicAcls == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor(childComplexity), true - - case "JobTriggeredActivityLogEntry.createdAt": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Job_kafkaTopicAcls_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Job.KafkaTopicAcls(childComplexity, args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true - case "JobTriggeredActivityLogEntry.environmentName": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName == nil { + case "Job.logDestinations": + if e.ComplexityRoot.Job.LogDestinations == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Job.LogDestinations(childComplexity), true - case "JobTriggeredActivityLogEntry.id": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ID == nil { + case "Job.manifest": + if e.ComplexityRoot.Job.Manifest == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Job.Manifest(childComplexity), true - case "JobTriggeredActivityLogEntry.message": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.Message == nil { + case "Job.name": + if e.ComplexityRoot.Job.Name == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Job.Name(childComplexity), true - case "JobTriggeredActivityLogEntry.resourceName": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName == nil { + case "Job.networkPolicy": + if e.ComplexityRoot.Job.NetworkPolicy == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Job.NetworkPolicy(childComplexity), true - case "JobTriggeredActivityLogEntry.resourceType": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType == nil { + case "Job.openSearch": + if e.ComplexityRoot.Job.OpenSearch == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Job.OpenSearch(childComplexity), true - case "JobTriggeredActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug == nil { + case "Job.postgresInstances": + if e.ComplexityRoot.Job.PostgresInstances == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true - - case "KafkaCredentials.accessCert": - if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { - break + args, err := ec.field_Job_postgresInstances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaCredentials.AccessCert(childComplexity), true + return e.ComplexityRoot.Job.PostgresInstances(childComplexity, args["orderBy"].(*postgres.PostgresInstanceOrder)), true - case "KafkaCredentials.accessKey": - if e.ComplexityRoot.KafkaCredentials.AccessKey == nil { + case "Job.resources": + if e.ComplexityRoot.Job.Resources == nil { break } - return e.ComplexityRoot.KafkaCredentials.AccessKey(childComplexity), true + return e.ComplexityRoot.Job.Resources(childComplexity), true - case "KafkaCredentials.brokers": - if e.ComplexityRoot.KafkaCredentials.Brokers == nil { + case "Job.runs": + if e.ComplexityRoot.Job.Runs == nil { break } - return e.ComplexityRoot.KafkaCredentials.Brokers(childComplexity), true + args, err := ec.field_Job_runs_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "KafkaCredentials.caCert": - if e.ComplexityRoot.KafkaCredentials.CaCert == nil { + return e.ComplexityRoot.Job.Runs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Job.sqlInstances": + if e.ComplexityRoot.Job.SQLInstances == nil { break } - return e.ComplexityRoot.KafkaCredentials.CaCert(childComplexity), true + args, err := ec.field_Job_sqlInstances_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "KafkaCredentials.schemaRegistry": - if e.ComplexityRoot.KafkaCredentials.SchemaRegistry == nil { + return e.ComplexityRoot.Job.SQLInstances(childComplexity, args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + + case "Job.schedule": + if e.ComplexityRoot.Job.Schedule == nil { break } - return e.ComplexityRoot.KafkaCredentials.SchemaRegistry(childComplexity), true + return e.ComplexityRoot.Job.Schedule(childComplexity), true - case "KafkaCredentials.username": - if e.ComplexityRoot.KafkaCredentials.Username == nil { + case "Job.secrets": + if e.ComplexityRoot.Job.Secrets == nil { break } - return e.ComplexityRoot.KafkaCredentials.Username(childComplexity), true + args, err := ec.field_Job_secrets_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "KafkaLagScalingStrategy.consumerGroup": - if e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup == nil { + return e.ComplexityRoot.Job.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Job.state": + if e.ComplexityRoot.Job.State == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup(childComplexity), true + return e.ComplexityRoot.Job.State(childComplexity), true - case "KafkaLagScalingStrategy.threshold": - if e.ComplexityRoot.KafkaLagScalingStrategy.Threshold == nil { + case "Job.team": + if e.ComplexityRoot.Job.Team == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.Threshold(childComplexity), true + return e.ComplexityRoot.Job.Team(childComplexity), true - case "KafkaLagScalingStrategy.topicName": - if e.ComplexityRoot.KafkaLagScalingStrategy.TopicName == nil { + case "Job.teamEnvironment": + if e.ComplexityRoot.Job.TeamEnvironment == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.TopicName(childComplexity), true + return e.ComplexityRoot.Job.TeamEnvironment(childComplexity), true - case "KafkaTopic.acl": - if e.ComplexityRoot.KafkaTopic.ACL == nil { + case "Job.valkeys": + if e.ComplexityRoot.Job.Valkeys == nil { break } - args, err := ec.field_KafkaTopic_acl_args(ctx, rawArgs) + args, err := ec.field_Job_valkeys_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.KafkaTopic.ACL(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*kafkatopic.KafkaTopicACLFilter), args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true + return e.ComplexityRoot.Job.Valkeys(childComplexity, args["orderBy"].(*valkey.ValkeyOrder)), true - case "KafkaTopic.configuration": - if e.ComplexityRoot.KafkaTopic.Configuration == nil { + case "Job.vulnerabilityFixHistory": + if e.ComplexityRoot.Job.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.KafkaTopic.Configuration(childComplexity), true - - case "KafkaTopic.environment": - if e.ComplexityRoot.KafkaTopic.Environment == nil { - break + args, err := ec.field_Job_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopic.Environment(childComplexity), true + return e.ComplexityRoot.Job.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "KafkaTopic.id": - if e.ComplexityRoot.KafkaTopic.ID == nil { + case "JobConnection.edges": + if e.ComplexityRoot.JobConnection.Edges == nil { break } - return e.ComplexityRoot.KafkaTopic.ID(childComplexity), true + return e.ComplexityRoot.JobConnection.Edges(childComplexity), true - case "KafkaTopic.name": - if e.ComplexityRoot.KafkaTopic.Name == nil { + case "JobConnection.nodes": + if e.ComplexityRoot.JobConnection.Nodes == nil { break } - return e.ComplexityRoot.KafkaTopic.Name(childComplexity), true + return e.ComplexityRoot.JobConnection.Nodes(childComplexity), true - case "KafkaTopic.pool": - if e.ComplexityRoot.KafkaTopic.Pool == nil { + case "JobConnection.pageInfo": + if e.ComplexityRoot.JobConnection.PageInfo == nil { break } - return e.ComplexityRoot.KafkaTopic.Pool(childComplexity), true + return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true - case "KafkaTopic.team": - if e.ComplexityRoot.KafkaTopic.Team == nil { + case "JobDeletedActivityLogEntry.actor": + if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.KafkaTopic.Team(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.Actor(childComplexity), true - case "KafkaTopic.teamEnvironment": - if e.ComplexityRoot.KafkaTopic.TeamEnvironment == nil { + case "JobDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.KafkaTopic.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "KafkaTopicAcl.access": - if e.ComplexityRoot.KafkaTopicAcl.Access == nil { + case "JobDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Access(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "KafkaTopicAcl.team": - if e.ComplexityRoot.KafkaTopicAcl.Team == nil { + case "JobDeletedActivityLogEntry.id": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Team(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ID(childComplexity), true - case "KafkaTopicAcl.teamName": - if e.ComplexityRoot.KafkaTopicAcl.TeamName == nil { + case "JobDeletedActivityLogEntry.message": + if e.ComplexityRoot.JobDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.TeamName(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.Message(childComplexity), true - case "KafkaTopicAcl.topic": - if e.ComplexityRoot.KafkaTopicAcl.Topic == nil { + case "JobDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Topic(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName(childComplexity), true - case "KafkaTopicAcl.workload": - if e.ComplexityRoot.KafkaTopicAcl.Workload == nil { + case "JobDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Workload(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType(childComplexity), true - case "KafkaTopicAcl.workloadName": - if e.ComplexityRoot.KafkaTopicAcl.WorkloadName == nil { + case "JobDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.WorkloadName(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "KafkaTopicAclConnection.edges": - if e.ComplexityRoot.KafkaTopicAclConnection.Edges == nil { + case "JobEdge.cursor": + if e.ComplexityRoot.JobEdge.Cursor == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.Edges(childComplexity), true + return e.ComplexityRoot.JobEdge.Cursor(childComplexity), true - case "KafkaTopicAclConnection.nodes": - if e.ComplexityRoot.KafkaTopicAclConnection.Nodes == nil { + case "JobEdge.node": + if e.ComplexityRoot.JobEdge.Node == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.Nodes(childComplexity), true + return e.ComplexityRoot.JobEdge.Node(childComplexity), true - case "KafkaTopicAclConnection.pageInfo": - if e.ComplexityRoot.KafkaTopicAclConnection.PageInfo == nil { + case "JobManifest.content": + if e.ComplexityRoot.JobManifest.Content == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.JobManifest.Content(childComplexity), true - case "KafkaTopicAclEdge.cursor": - if e.ComplexityRoot.KafkaTopicAclEdge.Cursor == nil { + case "JobResources.limits": + if e.ComplexityRoot.JobResources.Limits == nil { break } - return e.ComplexityRoot.KafkaTopicAclEdge.Cursor(childComplexity), true + return e.ComplexityRoot.JobResources.Limits(childComplexity), true - case "KafkaTopicAclEdge.node": - if e.ComplexityRoot.KafkaTopicAclEdge.Node == nil { + case "JobResources.requests": + if e.ComplexityRoot.JobResources.Requests == nil { break } - return e.ComplexityRoot.KafkaTopicAclEdge.Node(childComplexity), true + return e.ComplexityRoot.JobResources.Requests(childComplexity), true - case "KafkaTopicConfiguration.cleanupPolicy": - if e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy == nil { + case "JobRun.completionTime": + if e.ComplexityRoot.JobRun.CompletionTime == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy(childComplexity), true + return e.ComplexityRoot.JobRun.CompletionTime(childComplexity), true - case "KafkaTopicConfiguration.maxMessageBytes": - if e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes == nil { + case "JobRun.duration": + if e.ComplexityRoot.JobRun.Duration == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes(childComplexity), true + return e.ComplexityRoot.JobRun.Duration(childComplexity), true - case "KafkaTopicConfiguration.minimumInSyncReplicas": - if e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas == nil { + case "JobRun.id": + if e.ComplexityRoot.JobRun.ID == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas(childComplexity), true + return e.ComplexityRoot.JobRun.ID(childComplexity), true - case "KafkaTopicConfiguration.partitions": - if e.ComplexityRoot.KafkaTopicConfiguration.Partitions == nil { + case "JobRun.image": + if e.ComplexityRoot.JobRun.Image == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.Partitions(childComplexity), true + return e.ComplexityRoot.JobRun.Image(childComplexity), true - case "KafkaTopicConfiguration.replication": - if e.ComplexityRoot.KafkaTopicConfiguration.Replication == nil { + case "JobRun.instances": + if e.ComplexityRoot.JobRun.Instances == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.Replication(childComplexity), true - - case "KafkaTopicConfiguration.retentionBytes": - if e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes == nil { - break + args, err := ec.field_JobRun_instances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes(childComplexity), true + return e.ComplexityRoot.JobRun.Instances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "KafkaTopicConfiguration.retentionHours": - if e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours == nil { + case "JobRun.name": + if e.ComplexityRoot.JobRun.Name == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours(childComplexity), true + return e.ComplexityRoot.JobRun.Name(childComplexity), true - case "KafkaTopicConfiguration.segmentHours": - if e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours == nil { + case "JobRun.startTime": + if e.ComplexityRoot.JobRun.StartTime == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours(childComplexity), true + return e.ComplexityRoot.JobRun.StartTime(childComplexity), true - case "KafkaTopicConnection.edges": - if e.ComplexityRoot.KafkaTopicConnection.Edges == nil { + case "JobRun.status": + if e.ComplexityRoot.JobRun.Status == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.Edges(childComplexity), true + return e.ComplexityRoot.JobRun.Status(childComplexity), true - case "KafkaTopicConnection.nodes": - if e.ComplexityRoot.KafkaTopicConnection.Nodes == nil { + case "JobRun.trigger": + if e.ComplexityRoot.JobRun.Trigger == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.Nodes(childComplexity), true + return e.ComplexityRoot.JobRun.Trigger(childComplexity), true - case "KafkaTopicConnection.pageInfo": - if e.ComplexityRoot.KafkaTopicConnection.PageInfo == nil { + case "JobRunConnection.edges": + if e.ComplexityRoot.JobRunConnection.Edges == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.JobRunConnection.Edges(childComplexity), true - case "KafkaTopicEdge.cursor": - if e.ComplexityRoot.KafkaTopicEdge.Cursor == nil { + case "JobRunConnection.nodes": + if e.ComplexityRoot.JobRunConnection.Nodes == nil { break } - return e.ComplexityRoot.KafkaTopicEdge.Cursor(childComplexity), true + return e.ComplexityRoot.JobRunConnection.Nodes(childComplexity), true - case "KafkaTopicEdge.node": - if e.ComplexityRoot.KafkaTopicEdge.Node == nil { + case "JobRunConnection.pageInfo": + if e.ComplexityRoot.JobRunConnection.PageInfo == nil { break } - return e.ComplexityRoot.KafkaTopicEdge.Node(childComplexity), true + return e.ComplexityRoot.JobRunConnection.PageInfo(childComplexity), true - case "LastRunFailedIssue.id": - if e.ComplexityRoot.LastRunFailedIssue.ID == nil { + case "JobRunEdge.cursor": + if e.ComplexityRoot.JobRunEdge.Cursor == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.ID(childComplexity), true + return e.ComplexityRoot.JobRunEdge.Cursor(childComplexity), true - case "LastRunFailedIssue.job": - if e.ComplexityRoot.LastRunFailedIssue.Job == nil { + case "JobRunEdge.node": + if e.ComplexityRoot.JobRunEdge.Node == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Job(childComplexity), true + return e.ComplexityRoot.JobRunEdge.Node(childComplexity), true - case "LastRunFailedIssue.message": - if e.ComplexityRoot.LastRunFailedIssue.Message == nil { + case "JobRunInstance.id": + if e.ComplexityRoot.JobRunInstance.ID == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Message(childComplexity), true + return e.ComplexityRoot.JobRunInstance.ID(childComplexity), true - case "LastRunFailedIssue.severity": - if e.ComplexityRoot.LastRunFailedIssue.Severity == nil { + case "JobRunInstance.name": + if e.ComplexityRoot.JobRunInstance.Name == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Severity(childComplexity), true + return e.ComplexityRoot.JobRunInstance.Name(childComplexity), true - case "LastRunFailedIssue.teamEnvironment": - if e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment == nil { + case "JobRunInstanceConnection.edges": + if e.ComplexityRoot.JobRunInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.Edges(childComplexity), true - case "LogDestinationGeneric.id": - if e.ComplexityRoot.LogDestinationGeneric.ID == nil { + case "JobRunInstanceConnection.nodes": + if e.ComplexityRoot.JobRunInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.LogDestinationGeneric.ID(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.Nodes(childComplexity), true - case "LogDestinationGeneric.name": - if e.ComplexityRoot.LogDestinationGeneric.Name == nil { + case "JobRunInstanceConnection.pageInfo": + if e.ComplexityRoot.JobRunInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.LogDestinationGeneric.Name(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.PageInfo(childComplexity), true - case "LogDestinationLoki.grafanaURL": - if e.ComplexityRoot.LogDestinationLoki.GrafanaURL == nil { + case "JobRunInstanceEdge.cursor": + if e.ComplexityRoot.JobRunInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.LogDestinationLoki.GrafanaURL(childComplexity), true + return e.ComplexityRoot.JobRunInstanceEdge.Cursor(childComplexity), true - case "LogDestinationLoki.id": - if e.ComplexityRoot.LogDestinationLoki.ID == nil { + case "JobRunInstanceEdge.node": + if e.ComplexityRoot.JobRunInstanceEdge.Node == nil { break } - return e.ComplexityRoot.LogDestinationLoki.ID(childComplexity), true + return e.ComplexityRoot.JobRunInstanceEdge.Node(childComplexity), true - case "LogDestinationSecureLogs.id": - if e.ComplexityRoot.LogDestinationSecureLogs.ID == nil { + case "JobRunStatus.message": + if e.ComplexityRoot.JobRunStatus.Message == nil { break } - return e.ComplexityRoot.LogDestinationSecureLogs.ID(childComplexity), true + return e.ComplexityRoot.JobRunStatus.Message(childComplexity), true - case "LogLine.labels": - if e.ComplexityRoot.LogLine.Labels == nil { + case "JobRunStatus.state": + if e.ComplexityRoot.JobRunStatus.State == nil { break } - return e.ComplexityRoot.LogLine.Labels(childComplexity), true + return e.ComplexityRoot.JobRunStatus.State(childComplexity), true - case "LogLine.message": - if e.ComplexityRoot.LogLine.Message == nil { + case "JobRunTrigger.actor": + if e.ComplexityRoot.JobRunTrigger.Actor == nil { break } - return e.ComplexityRoot.LogLine.Message(childComplexity), true + return e.ComplexityRoot.JobRunTrigger.Actor(childComplexity), true - case "LogLine.time": - if e.ComplexityRoot.LogLine.Time == nil { + case "JobRunTrigger.type": + if e.ComplexityRoot.JobRunTrigger.Type == nil { break } - return e.ComplexityRoot.LogLine.Time(childComplexity), true + return e.ComplexityRoot.JobRunTrigger.Type(childComplexity), true - case "LogLineLabel.key": - if e.ComplexityRoot.LogLineLabel.Key == nil { + case "JobSchedule.expression": + if e.ComplexityRoot.JobSchedule.Expression == nil { break } - return e.ComplexityRoot.LogLineLabel.Key(childComplexity), true + return e.ComplexityRoot.JobSchedule.Expression(childComplexity), true - case "LogLineLabel.value": - if e.ComplexityRoot.LogLineLabel.Value == nil { + case "JobSchedule.timeZone": + if e.ComplexityRoot.JobSchedule.TimeZone == nil { break } - return e.ComplexityRoot.LogLineLabel.Value(childComplexity), true + return e.ComplexityRoot.JobSchedule.TimeZone(childComplexity), true - case "MaintenanceWindow.dayOfWeek": - if e.ComplexityRoot.MaintenanceWindow.DayOfWeek == nil { + case "JobTriggeredActivityLogEntry.actor": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.MaintenanceWindow.DayOfWeek(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor(childComplexity), true - case "MaintenanceWindow.timeOfDay": - if e.ComplexityRoot.MaintenanceWindow.TimeOfDay == nil { + case "JobTriggeredActivityLogEntry.createdAt": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.MaintenanceWindow.TimeOfDay(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt(childComplexity), true - case "MaskinportenAuthIntegration.name": - if e.ComplexityRoot.MaskinportenAuthIntegration.Name == nil { + case "JobTriggeredActivityLogEntry.environmentName": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.MaskinportenAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName(childComplexity), true - case "MetricLabel.name": - if e.ComplexityRoot.MetricLabel.Name == nil { + case "JobTriggeredActivityLogEntry.id": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.MetricLabel.Name(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ID(childComplexity), true - case "MetricLabel.value": - if e.ComplexityRoot.MetricLabel.Value == nil { + case "JobTriggeredActivityLogEntry.message": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.MetricLabel.Value(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.Message(childComplexity), true - case "MetricSeries.labels": - if e.ComplexityRoot.MetricSeries.Labels == nil { + case "JobTriggeredActivityLogEntry.resourceName": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.MetricSeries.Labels(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName(childComplexity), true - case "MetricSeries.values": - if e.ComplexityRoot.MetricSeries.Values == nil { + case "JobTriggeredActivityLogEntry.resourceType": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.MetricSeries.Values(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType(childComplexity), true - case "MetricValue.timestamp": - if e.ComplexityRoot.MetricValue.Timestamp == nil { + case "JobTriggeredActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.MetricValue.Timestamp(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true - case "MetricValue.value": - if e.ComplexityRoot.MetricValue.Value == nil { + case "KafkaCredentials.accessCert": + if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { break } - return e.ComplexityRoot.MetricValue.Value(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.AccessCert(childComplexity), true - case "MetricsQueryResult.series": - if e.ComplexityRoot.MetricsQueryResult.Series == nil { + case "KafkaCredentials.accessKey": + if e.ComplexityRoot.KafkaCredentials.AccessKey == nil { break } - return e.ComplexityRoot.MetricsQueryResult.Series(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.AccessKey(childComplexity), true - case "MetricsQueryResult.warnings": - if e.ComplexityRoot.MetricsQueryResult.Warnings == nil { + case "KafkaCredentials.brokers": + if e.ComplexityRoot.KafkaCredentials.Brokers == nil { break } - return e.ComplexityRoot.MetricsQueryResult.Warnings(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.Brokers(childComplexity), true - case "MissingSbomIssue.id": - if e.ComplexityRoot.MissingSbomIssue.ID == nil { + case "KafkaCredentials.caCert": + if e.ComplexityRoot.KafkaCredentials.CaCert == nil { break } - return e.ComplexityRoot.MissingSbomIssue.ID(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.CaCert(childComplexity), true - case "MissingSbomIssue.message": - if e.ComplexityRoot.MissingSbomIssue.Message == nil { + case "KafkaCredentials.schemaRegistry": + if e.ComplexityRoot.KafkaCredentials.SchemaRegistry == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Message(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.SchemaRegistry(childComplexity), true - case "MissingSbomIssue.severity": - if e.ComplexityRoot.MissingSbomIssue.Severity == nil { + case "KafkaCredentials.username": + if e.ComplexityRoot.KafkaCredentials.Username == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Severity(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.Username(childComplexity), true - case "MissingSbomIssue.teamEnvironment": - if e.ComplexityRoot.MissingSbomIssue.TeamEnvironment == nil { + case "KafkaLagScalingStrategy.consumerGroup": + if e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup == nil { break } - return e.ComplexityRoot.MissingSbomIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup(childComplexity), true - case "MissingSbomIssue.workload": - if e.ComplexityRoot.MissingSbomIssue.Workload == nil { + case "KafkaLagScalingStrategy.threshold": + if e.ComplexityRoot.KafkaLagScalingStrategy.Threshold == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Workload(childComplexity), true + return e.ComplexityRoot.KafkaLagScalingStrategy.Threshold(childComplexity), true - case "Mutation.addRepositoryToTeam": - if e.ComplexityRoot.Mutation.AddRepositoryToTeam == nil { + case "KafkaLagScalingStrategy.topicName": + if e.ComplexityRoot.KafkaLagScalingStrategy.TopicName == nil { break } - args, err := ec.field_Mutation_addRepositoryToTeam_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Mutation.AddRepositoryToTeam(childComplexity, args["input"].(repository.AddRepositoryToTeamInput)), true + return e.ComplexityRoot.KafkaLagScalingStrategy.TopicName(childComplexity), true - case "Mutation.addSecretValue": - if e.ComplexityRoot.Mutation.AddSecretValue == nil { + case "KafkaTopic.acl": + if e.ComplexityRoot.KafkaTopic.ACL == nil { break } - args, err := ec.field_Mutation_addSecretValue_args(ctx, rawArgs) + args, err := ec.field_KafkaTopic_acl_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AddSecretValue(childComplexity, args["input"].(secret.AddSecretValueInput)), true + return e.ComplexityRoot.KafkaTopic.ACL(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*kafkatopic.KafkaTopicACLFilter), args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true - case "Mutation.addTeamMember": - if e.ComplexityRoot.Mutation.AddTeamMember == nil { + case "KafkaTopic.configuration": + if e.ComplexityRoot.KafkaTopic.Configuration == nil { break } - args, err := ec.field_Mutation_addTeamMember_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Mutation.AddTeamMember(childComplexity, args["input"].(team.AddTeamMemberInput)), true + return e.ComplexityRoot.KafkaTopic.Configuration(childComplexity), true - case "Mutation.allowTeamAccessToUnleash": - if e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash == nil { + case "KafkaTopic.environment": + if e.ComplexityRoot.KafkaTopic.Environment == nil { break } - args, err := ec.field_Mutation_allowTeamAccessToUnleash_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.Environment(childComplexity), true + + case "KafkaTopic.id": + if e.ComplexityRoot.KafkaTopic.ID == nil { + break } - return e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash(childComplexity, args["input"].(unleash.AllowTeamAccessToUnleashInput)), true + return e.ComplexityRoot.KafkaTopic.ID(childComplexity), true - case "Mutation.assignRoleToServiceAccount": - if e.ComplexityRoot.Mutation.AssignRoleToServiceAccount == nil { + case "KafkaTopic.name": + if e.ComplexityRoot.KafkaTopic.Name == nil { break } - args, err := ec.field_Mutation_assignRoleToServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.Name(childComplexity), true + + case "KafkaTopic.pool": + if e.ComplexityRoot.KafkaTopic.Pool == nil { + break } - return e.ComplexityRoot.Mutation.AssignRoleToServiceAccount(childComplexity, args["input"].(serviceaccount.AssignRoleToServiceAccountInput)), true + return e.ComplexityRoot.KafkaTopic.Pool(childComplexity), true - case "Mutation.changeDeploymentKey": - if e.ComplexityRoot.Mutation.ChangeDeploymentKey == nil { + case "KafkaTopic.team": + if e.ComplexityRoot.KafkaTopic.Team == nil { break } - args, err := ec.field_Mutation_changeDeploymentKey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.Team(childComplexity), true + + case "KafkaTopic.teamEnvironment": + if e.ComplexityRoot.KafkaTopic.TeamEnvironment == nil { + break } - return e.ComplexityRoot.Mutation.ChangeDeploymentKey(childComplexity, args["input"].(deployment.ChangeDeploymentKeyInput)), true + return e.ComplexityRoot.KafkaTopic.TeamEnvironment(childComplexity), true - case "Mutation.configureReconciler": - if e.ComplexityRoot.Mutation.ConfigureReconciler == nil { + case "KafkaTopicAcl.access": + if e.ComplexityRoot.KafkaTopicAcl.Access == nil { break } - args, err := ec.field_Mutation_configureReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAcl.Access(childComplexity), true + + case "KafkaTopicAcl.team": + if e.ComplexityRoot.KafkaTopicAcl.Team == nil { + break } - return e.ComplexityRoot.Mutation.ConfigureReconciler(childComplexity, args["input"].(reconciler.ConfigureReconcilerInput)), true + return e.ComplexityRoot.KafkaTopicAcl.Team(childComplexity), true - case "Mutation.confirmTeamDeletion": - if e.ComplexityRoot.Mutation.ConfirmTeamDeletion == nil { + case "KafkaTopicAcl.teamName": + if e.ComplexityRoot.KafkaTopicAcl.TeamName == nil { break } - args, err := ec.field_Mutation_confirmTeamDeletion_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAcl.TeamName(childComplexity), true + + case "KafkaTopicAcl.topic": + if e.ComplexityRoot.KafkaTopicAcl.Topic == nil { + break } - return e.ComplexityRoot.Mutation.ConfirmTeamDeletion(childComplexity, args["input"].(team.ConfirmTeamDeletionInput)), true + return e.ComplexityRoot.KafkaTopicAcl.Topic(childComplexity), true - case "Mutation.createKafkaCredentials": - if e.ComplexityRoot.Mutation.CreateKafkaCredentials == nil { + case "KafkaTopicAcl.workload": + if e.ComplexityRoot.KafkaTopicAcl.Workload == nil { break } - args, err := ec.field_Mutation_createKafkaCredentials_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAcl.Workload(childComplexity), true + + case "KafkaTopicAcl.workloadName": + if e.ComplexityRoot.KafkaTopicAcl.WorkloadName == nil { + break } - return e.ComplexityRoot.Mutation.CreateKafkaCredentials(childComplexity, args["input"].(aivencredentials.CreateKafkaCredentialsInput)), true + return e.ComplexityRoot.KafkaTopicAcl.WorkloadName(childComplexity), true - case "Mutation.createOpenSearch": - if e.ComplexityRoot.Mutation.CreateOpenSearch == nil { + case "KafkaTopicAclConnection.edges": + if e.ComplexityRoot.KafkaTopicAclConnection.Edges == nil { break } - args, err := ec.field_Mutation_createOpenSearch_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAclConnection.Edges(childComplexity), true + + case "KafkaTopicAclConnection.nodes": + if e.ComplexityRoot.KafkaTopicAclConnection.Nodes == nil { + break } - return e.ComplexityRoot.Mutation.CreateOpenSearch(childComplexity, args["input"].(opensearch.CreateOpenSearchInput)), true + return e.ComplexityRoot.KafkaTopicAclConnection.Nodes(childComplexity), true - case "Mutation.createOpenSearchCredentials": - if e.ComplexityRoot.Mutation.CreateOpenSearchCredentials == nil { + case "KafkaTopicAclConnection.pageInfo": + if e.ComplexityRoot.KafkaTopicAclConnection.PageInfo == nil { break } - args, err := ec.field_Mutation_createOpenSearchCredentials_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAclConnection.PageInfo(childComplexity), true + + case "KafkaTopicAclEdge.cursor": + if e.ComplexityRoot.KafkaTopicAclEdge.Cursor == nil { + break } - return e.ComplexityRoot.Mutation.CreateOpenSearchCredentials(childComplexity, args["input"].(aivencredentials.CreateOpenSearchCredentialsInput)), true + return e.ComplexityRoot.KafkaTopicAclEdge.Cursor(childComplexity), true - case "Mutation.createSecret": - if e.ComplexityRoot.Mutation.CreateSecret == nil { + case "KafkaTopicAclEdge.node": + if e.ComplexityRoot.KafkaTopicAclEdge.Node == nil { break } - args, err := ec.field_Mutation_createSecret_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAclEdge.Node(childComplexity), true + + case "KafkaTopicConfiguration.cleanupPolicy": + if e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy == nil { + break } - return e.ComplexityRoot.Mutation.CreateSecret(childComplexity, args["input"].(secret.CreateSecretInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy(childComplexity), true - case "Mutation.createServiceAccount": - if e.ComplexityRoot.Mutation.CreateServiceAccount == nil { + case "KafkaTopicConfiguration.maxMessageBytes": + if e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes == nil { break } - args, err := ec.field_Mutation_createServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes(childComplexity), true + + case "KafkaTopicConfiguration.minimumInSyncReplicas": + if e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas == nil { + break } - return e.ComplexityRoot.Mutation.CreateServiceAccount(childComplexity, args["input"].(serviceaccount.CreateServiceAccountInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas(childComplexity), true - case "Mutation.createServiceAccountToken": - if e.ComplexityRoot.Mutation.CreateServiceAccountToken == nil { + case "KafkaTopicConfiguration.partitions": + if e.ComplexityRoot.KafkaTopicConfiguration.Partitions == nil { break } - args, err := ec.field_Mutation_createServiceAccountToken_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.Partitions(childComplexity), true + + case "KafkaTopicConfiguration.replication": + if e.ComplexityRoot.KafkaTopicConfiguration.Replication == nil { + break } - return e.ComplexityRoot.Mutation.CreateServiceAccountToken(childComplexity, args["input"].(serviceaccount.CreateServiceAccountTokenInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.Replication(childComplexity), true - case "Mutation.createTeam": - if e.ComplexityRoot.Mutation.CreateTeam == nil { + case "KafkaTopicConfiguration.retentionBytes": + if e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes == nil { break } - args, err := ec.field_Mutation_createTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes(childComplexity), true + + case "KafkaTopicConfiguration.retentionHours": + if e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours == nil { + break } - return e.ComplexityRoot.Mutation.CreateTeam(childComplexity, args["input"].(team.CreateTeamInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours(childComplexity), true - case "Mutation.createUnleashForTeam": - if e.ComplexityRoot.Mutation.CreateUnleashForTeam == nil { + case "KafkaTopicConfiguration.segmentHours": + if e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours == nil { break } - args, err := ec.field_Mutation_createUnleashForTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours(childComplexity), true + + case "KafkaTopicConnection.edges": + if e.ComplexityRoot.KafkaTopicConnection.Edges == nil { + break } - return e.ComplexityRoot.Mutation.CreateUnleashForTeam(childComplexity, args["input"].(unleash.CreateUnleashForTeamInput)), true + return e.ComplexityRoot.KafkaTopicConnection.Edges(childComplexity), true - case "Mutation.createValkey": - if e.ComplexityRoot.Mutation.CreateValkey == nil { + case "KafkaTopicConnection.nodes": + if e.ComplexityRoot.KafkaTopicConnection.Nodes == nil { break } - args, err := ec.field_Mutation_createValkey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConnection.Nodes(childComplexity), true + + case "KafkaTopicConnection.pageInfo": + if e.ComplexityRoot.KafkaTopicConnection.PageInfo == nil { + break } - return e.ComplexityRoot.Mutation.CreateValkey(childComplexity, args["input"].(valkey.CreateValkeyInput)), true + return e.ComplexityRoot.KafkaTopicConnection.PageInfo(childComplexity), true - case "Mutation.createValkeyCredentials": - if e.ComplexityRoot.Mutation.CreateValkeyCredentials == nil { + case "KafkaTopicEdge.cursor": + if e.ComplexityRoot.KafkaTopicEdge.Cursor == nil { break } - args, err := ec.field_Mutation_createValkeyCredentials_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicEdge.Cursor(childComplexity), true + + case "KafkaTopicEdge.node": + if e.ComplexityRoot.KafkaTopicEdge.Node == nil { + break } - return e.ComplexityRoot.Mutation.CreateValkeyCredentials(childComplexity, args["input"].(aivencredentials.CreateValkeyCredentialsInput)), true + return e.ComplexityRoot.KafkaTopicEdge.Node(childComplexity), true - case "Mutation.deleteApplication": - if e.ComplexityRoot.Mutation.DeleteApplication == nil { + case "LastRunFailedIssue.id": + if e.ComplexityRoot.LastRunFailedIssue.ID == nil { break } - args, err := ec.field_Mutation_deleteApplication_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LastRunFailedIssue.ID(childComplexity), true + + case "LastRunFailedIssue.job": + if e.ComplexityRoot.LastRunFailedIssue.Job == nil { + break } - return e.ComplexityRoot.Mutation.DeleteApplication(childComplexity, args["input"].(application.DeleteApplicationInput)), true + return e.ComplexityRoot.LastRunFailedIssue.Job(childComplexity), true - case "Mutation.deleteJob": - if e.ComplexityRoot.Mutation.DeleteJob == nil { + case "LastRunFailedIssue.message": + if e.ComplexityRoot.LastRunFailedIssue.Message == nil { break } - args, err := ec.field_Mutation_deleteJob_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LastRunFailedIssue.Message(childComplexity), true + + case "LastRunFailedIssue.severity": + if e.ComplexityRoot.LastRunFailedIssue.Severity == nil { + break } - return e.ComplexityRoot.Mutation.DeleteJob(childComplexity, args["input"].(job.DeleteJobInput)), true + return e.ComplexityRoot.LastRunFailedIssue.Severity(childComplexity), true - case "Mutation.deleteOpenSearch": - if e.ComplexityRoot.Mutation.DeleteOpenSearch == nil { + case "LastRunFailedIssue.teamEnvironment": + if e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment == nil { break } - args, err := ec.field_Mutation_deleteOpenSearch_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment(childComplexity), true + + case "LogDestinationGeneric.id": + if e.ComplexityRoot.LogDestinationGeneric.ID == nil { + break } - return e.ComplexityRoot.Mutation.DeleteOpenSearch(childComplexity, args["input"].(opensearch.DeleteOpenSearchInput)), true + return e.ComplexityRoot.LogDestinationGeneric.ID(childComplexity), true - case "Mutation.deleteSecret": - if e.ComplexityRoot.Mutation.DeleteSecret == nil { + case "LogDestinationGeneric.name": + if e.ComplexityRoot.LogDestinationGeneric.Name == nil { break } - args, err := ec.field_Mutation_deleteSecret_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogDestinationGeneric.Name(childComplexity), true + + case "LogDestinationLoki.grafanaURL": + if e.ComplexityRoot.LogDestinationLoki.GrafanaURL == nil { + break } - return e.ComplexityRoot.Mutation.DeleteSecret(childComplexity, args["input"].(secret.DeleteSecretInput)), true + return e.ComplexityRoot.LogDestinationLoki.GrafanaURL(childComplexity), true - case "Mutation.deleteServiceAccount": - if e.ComplexityRoot.Mutation.DeleteServiceAccount == nil { + case "LogDestinationLoki.id": + if e.ComplexityRoot.LogDestinationLoki.ID == nil { break } - args, err := ec.field_Mutation_deleteServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogDestinationLoki.ID(childComplexity), true + + case "LogDestinationSecureLogs.id": + if e.ComplexityRoot.LogDestinationSecureLogs.ID == nil { + break } - return e.ComplexityRoot.Mutation.DeleteServiceAccount(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountInput)), true + return e.ComplexityRoot.LogDestinationSecureLogs.ID(childComplexity), true - case "Mutation.deleteServiceAccountToken": - if e.ComplexityRoot.Mutation.DeleteServiceAccountToken == nil { + case "LogLine.labels": + if e.ComplexityRoot.LogLine.Labels == nil { break } - args, err := ec.field_Mutation_deleteServiceAccountToken_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogLine.Labels(childComplexity), true + + case "LogLine.message": + if e.ComplexityRoot.LogLine.Message == nil { + break } - return e.ComplexityRoot.Mutation.DeleteServiceAccountToken(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountTokenInput)), true + return e.ComplexityRoot.LogLine.Message(childComplexity), true - case "Mutation.deleteUnleashInstance": - if e.ComplexityRoot.Mutation.DeleteUnleashInstance == nil { + case "LogLine.time": + if e.ComplexityRoot.LogLine.Time == nil { break } - args, err := ec.field_Mutation_deleteUnleashInstance_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogLine.Time(childComplexity), true + + case "LogLineLabel.key": + if e.ComplexityRoot.LogLineLabel.Key == nil { + break } - return e.ComplexityRoot.Mutation.DeleteUnleashInstance(childComplexity, args["input"].(unleash.DeleteUnleashInstanceInput)), true + return e.ComplexityRoot.LogLineLabel.Key(childComplexity), true - case "Mutation.deleteValkey": - if e.ComplexityRoot.Mutation.DeleteValkey == nil { + case "LogLineLabel.value": + if e.ComplexityRoot.LogLineLabel.Value == nil { break } - args, err := ec.field_Mutation_deleteValkey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogLineLabel.Value(childComplexity), true + + case "MaintenanceWindow.dayOfWeek": + if e.ComplexityRoot.MaintenanceWindow.DayOfWeek == nil { + break } - return e.ComplexityRoot.Mutation.DeleteValkey(childComplexity, args["input"].(valkey.DeleteValkeyInput)), true + return e.ComplexityRoot.MaintenanceWindow.DayOfWeek(childComplexity), true - case "Mutation.disableReconciler": - if e.ComplexityRoot.Mutation.DisableReconciler == nil { + case "MaintenanceWindow.timeOfDay": + if e.ComplexityRoot.MaintenanceWindow.TimeOfDay == nil { break } - args, err := ec.field_Mutation_disableReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MaintenanceWindow.TimeOfDay(childComplexity), true + + case "MaskinportenAuthIntegration.name": + if e.ComplexityRoot.MaskinportenAuthIntegration.Name == nil { + break } - return e.ComplexityRoot.Mutation.DisableReconciler(childComplexity, args["input"].(reconciler.DisableReconcilerInput)), true + return e.ComplexityRoot.MaskinportenAuthIntegration.Name(childComplexity), true - case "Mutation.enableReconciler": - if e.ComplexityRoot.Mutation.EnableReconciler == nil { + case "MetricLabel.name": + if e.ComplexityRoot.MetricLabel.Name == nil { break } - args, err := ec.field_Mutation_enableReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricLabel.Name(childComplexity), true + + case "MetricLabel.value": + if e.ComplexityRoot.MetricLabel.Value == nil { + break } - return e.ComplexityRoot.Mutation.EnableReconciler(childComplexity, args["input"].(reconciler.EnableReconcilerInput)), true + return e.ComplexityRoot.MetricLabel.Value(childComplexity), true - case "Mutation.grantPostgresAccess": - if e.ComplexityRoot.Mutation.GrantPostgresAccess == nil { + case "MetricSeries.labels": + if e.ComplexityRoot.MetricSeries.Labels == nil { break } - args, err := ec.field_Mutation_grantPostgresAccess_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricSeries.Labels(childComplexity), true + + case "MetricSeries.values": + if e.ComplexityRoot.MetricSeries.Values == nil { + break } - return e.ComplexityRoot.Mutation.GrantPostgresAccess(childComplexity, args["input"].(postgres.GrantPostgresAccessInput)), true + return e.ComplexityRoot.MetricSeries.Values(childComplexity), true - case "Mutation.removeRepositoryFromTeam": - if e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam == nil { + case "MetricValue.timestamp": + if e.ComplexityRoot.MetricValue.Timestamp == nil { break } - args, err := ec.field_Mutation_removeRepositoryFromTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricValue.Timestamp(childComplexity), true + + case "MetricValue.value": + if e.ComplexityRoot.MetricValue.Value == nil { + break } - return e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam(childComplexity, args["input"].(repository.RemoveRepositoryFromTeamInput)), true + return e.ComplexityRoot.MetricValue.Value(childComplexity), true - case "Mutation.removeSecretValue": - if e.ComplexityRoot.Mutation.RemoveSecretValue == nil { + case "MetricsQueryResult.series": + if e.ComplexityRoot.MetricsQueryResult.Series == nil { break } - args, err := ec.field_Mutation_removeSecretValue_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricsQueryResult.Series(childComplexity), true + + case "MetricsQueryResult.warnings": + if e.ComplexityRoot.MetricsQueryResult.Warnings == nil { + break } - return e.ComplexityRoot.Mutation.RemoveSecretValue(childComplexity, args["input"].(secret.RemoveSecretValueInput)), true + return e.ComplexityRoot.MetricsQueryResult.Warnings(childComplexity), true - case "Mutation.removeTeamMember": - if e.ComplexityRoot.Mutation.RemoveTeamMember == nil { + case "MissingSbomIssue.id": + if e.ComplexityRoot.MissingSbomIssue.ID == nil { break } - args, err := ec.field_Mutation_removeTeamMember_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MissingSbomIssue.ID(childComplexity), true + + case "MissingSbomIssue.message": + if e.ComplexityRoot.MissingSbomIssue.Message == nil { + break } - return e.ComplexityRoot.Mutation.RemoveTeamMember(childComplexity, args["input"].(team.RemoveTeamMemberInput)), true + return e.ComplexityRoot.MissingSbomIssue.Message(childComplexity), true - case "Mutation.requestTeamDeletion": - if e.ComplexityRoot.Mutation.RequestTeamDeletion == nil { + case "MissingSbomIssue.severity": + if e.ComplexityRoot.MissingSbomIssue.Severity == nil { break } - args, err := ec.field_Mutation_requestTeamDeletion_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MissingSbomIssue.Severity(childComplexity), true + + case "MissingSbomIssue.teamEnvironment": + if e.ComplexityRoot.MissingSbomIssue.TeamEnvironment == nil { + break } - return e.ComplexityRoot.Mutation.RequestTeamDeletion(childComplexity, args["input"].(team.RequestTeamDeletionInput)), true + return e.ComplexityRoot.MissingSbomIssue.TeamEnvironment(childComplexity), true - case "Mutation.restartApplication": - if e.ComplexityRoot.Mutation.RestartApplication == nil { + case "MissingSbomIssue.workload": + if e.ComplexityRoot.MissingSbomIssue.Workload == nil { break } - args, err := ec.field_Mutation_restartApplication_args(ctx, rawArgs) + return e.ComplexityRoot.MissingSbomIssue.Workload(childComplexity), true + + case "Mutation.addConfigValue": + if e.ComplexityRoot.Mutation.AddConfigValue == nil { + break + } + + args, err := ec.field_Mutation_addConfigValue_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.RestartApplication(childComplexity, args["input"].(application.RestartApplicationInput)), true + return e.ComplexityRoot.Mutation.AddConfigValue(childComplexity, args["input"].(configmap.AddConfigValueInput)), true - case "Mutation.revokeRoleFromServiceAccount": - if e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount == nil { + case "Mutation.addRepositoryToTeam": + if e.ComplexityRoot.Mutation.AddRepositoryToTeam == nil { break } - args, err := ec.field_Mutation_revokeRoleFromServiceAccount_args(ctx, rawArgs) + args, err := ec.field_Mutation_addRepositoryToTeam_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount(childComplexity, args["input"].(serviceaccount.RevokeRoleFromServiceAccountInput)), true + return e.ComplexityRoot.Mutation.AddRepositoryToTeam(childComplexity, args["input"].(repository.AddRepositoryToTeamInput)), true - case "Mutation.revokeTeamAccessToUnleash": - if e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash == nil { + case "Mutation.addSecretValue": + if e.ComplexityRoot.Mutation.AddSecretValue == nil { break } - args, err := ec.field_Mutation_revokeTeamAccessToUnleash_args(ctx, rawArgs) + args, err := ec.field_Mutation_addSecretValue_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash(childComplexity, args["input"].(unleash.RevokeTeamAccessToUnleashInput)), true + return e.ComplexityRoot.Mutation.AddSecretValue(childComplexity, args["input"].(secret.AddSecretValueInput)), true - case "Mutation.setTeamMemberRole": - if e.ComplexityRoot.Mutation.SetTeamMemberRole == nil { + case "Mutation.addTeamMember": + if e.ComplexityRoot.Mutation.AddTeamMember == nil { break } - args, err := ec.field_Mutation_setTeamMemberRole_args(ctx, rawArgs) + args, err := ec.field_Mutation_addTeamMember_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.SetTeamMemberRole(childComplexity, args["input"].(team.SetTeamMemberRoleInput)), true + return e.ComplexityRoot.Mutation.AddTeamMember(childComplexity, args["input"].(team.AddTeamMemberInput)), true - case "Mutation.startOpenSearchMaintenance": - if e.ComplexityRoot.Mutation.StartOpenSearchMaintenance == nil { + case "Mutation.allowTeamAccessToUnleash": + if e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash == nil { break } - args, err := ec.field_Mutation_startOpenSearchMaintenance_args(ctx, rawArgs) + args, err := ec.field_Mutation_allowTeamAccessToUnleash_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.StartOpenSearchMaintenance(childComplexity, args["input"].(servicemaintenance.StartOpenSearchMaintenanceInput)), true + return e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash(childComplexity, args["input"].(unleash.AllowTeamAccessToUnleashInput)), true - case "Mutation.startValkeyMaintenance": - if e.ComplexityRoot.Mutation.StartValkeyMaintenance == nil { + case "Mutation.assignRoleToServiceAccount": + if e.ComplexityRoot.Mutation.AssignRoleToServiceAccount == nil { break } - args, err := ec.field_Mutation_startValkeyMaintenance_args(ctx, rawArgs) + args, err := ec.field_Mutation_assignRoleToServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.StartValkeyMaintenance(childComplexity, args["input"].(servicemaintenance.StartValkeyMaintenanceInput)), true + return e.ComplexityRoot.Mutation.AssignRoleToServiceAccount(childComplexity, args["input"].(serviceaccount.AssignRoleToServiceAccountInput)), true - case "Mutation.triggerJob": - if e.ComplexityRoot.Mutation.TriggerJob == nil { + case "Mutation.changeDeploymentKey": + if e.ComplexityRoot.Mutation.ChangeDeploymentKey == nil { break } - args, err := ec.field_Mutation_triggerJob_args(ctx, rawArgs) + args, err := ec.field_Mutation_changeDeploymentKey_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.TriggerJob(childComplexity, args["input"].(job.TriggerJobInput)), true + return e.ComplexityRoot.Mutation.ChangeDeploymentKey(childComplexity, args["input"].(deployment.ChangeDeploymentKeyInput)), true - case "Mutation.updateImageVulnerability": - if e.ComplexityRoot.Mutation.UpdateImageVulnerability == nil { + case "Mutation.configureReconciler": + if e.ComplexityRoot.Mutation.ConfigureReconciler == nil { break } - args, err := ec.field_Mutation_updateImageVulnerability_args(ctx, rawArgs) + args, err := ec.field_Mutation_configureReconciler_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateImageVulnerability(childComplexity, args["input"].(vulnerability.UpdateImageVulnerabilityInput)), true + return e.ComplexityRoot.Mutation.ConfigureReconciler(childComplexity, args["input"].(reconciler.ConfigureReconcilerInput)), true - case "Mutation.updateOpenSearch": - if e.ComplexityRoot.Mutation.UpdateOpenSearch == nil { + case "Mutation.confirmTeamDeletion": + if e.ComplexityRoot.Mutation.ConfirmTeamDeletion == nil { break } - args, err := ec.field_Mutation_updateOpenSearch_args(ctx, rawArgs) + args, err := ec.field_Mutation_confirmTeamDeletion_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateOpenSearch(childComplexity, args["input"].(opensearch.UpdateOpenSearchInput)), true + return e.ComplexityRoot.Mutation.ConfirmTeamDeletion(childComplexity, args["input"].(team.ConfirmTeamDeletionInput)), true - case "Mutation.updateSecretValue": - if e.ComplexityRoot.Mutation.UpdateSecretValue == nil { + case "Mutation.createConfig": + if e.ComplexityRoot.Mutation.CreateConfig == nil { break } - args, err := ec.field_Mutation_updateSecretValue_args(ctx, rawArgs) + args, err := ec.field_Mutation_createConfig_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateSecretValue(childComplexity, args["input"].(secret.UpdateSecretValueInput)), true + return e.ComplexityRoot.Mutation.CreateConfig(childComplexity, args["input"].(configmap.CreateConfigInput)), true - case "Mutation.updateServiceAccount": - if e.ComplexityRoot.Mutation.UpdateServiceAccount == nil { + case "Mutation.createKafkaCredentials": + if e.ComplexityRoot.Mutation.CreateKafkaCredentials == nil { break } - args, err := ec.field_Mutation_updateServiceAccount_args(ctx, rawArgs) + args, err := ec.field_Mutation_createKafkaCredentials_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateServiceAccount(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountInput)), true + return e.ComplexityRoot.Mutation.CreateKafkaCredentials(childComplexity, args["input"].(aivencredentials.CreateKafkaCredentialsInput)), true - case "Mutation.updateServiceAccountToken": - if e.ComplexityRoot.Mutation.UpdateServiceAccountToken == nil { + case "Mutation.createOpenSearch": + if e.ComplexityRoot.Mutation.CreateOpenSearch == nil { break } - args, err := ec.field_Mutation_updateServiceAccountToken_args(ctx, rawArgs) + args, err := ec.field_Mutation_createOpenSearch_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateServiceAccountToken(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountTokenInput)), true + return e.ComplexityRoot.Mutation.CreateOpenSearch(childComplexity, args["input"].(opensearch.CreateOpenSearchInput)), true - case "Mutation.updateTeam": - if e.ComplexityRoot.Mutation.UpdateTeam == nil { + case "Mutation.createOpenSearchCredentials": + if e.ComplexityRoot.Mutation.CreateOpenSearchCredentials == nil { break } - args, err := ec.field_Mutation_updateTeam_args(ctx, rawArgs) + args, err := ec.field_Mutation_createOpenSearchCredentials_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateTeam(childComplexity, args["input"].(team.UpdateTeamInput)), true + return e.ComplexityRoot.Mutation.CreateOpenSearchCredentials(childComplexity, args["input"].(aivencredentials.CreateOpenSearchCredentialsInput)), true - case "Mutation.updateTeamEnvironment": - if e.ComplexityRoot.Mutation.UpdateTeamEnvironment == nil { + case "Mutation.createSecret": + if e.ComplexityRoot.Mutation.CreateSecret == nil { break } - args, err := ec.field_Mutation_updateTeamEnvironment_args(ctx, rawArgs) + args, err := ec.field_Mutation_createSecret_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateTeamEnvironment(childComplexity, args["input"].(team.UpdateTeamEnvironmentInput)), true + return e.ComplexityRoot.Mutation.CreateSecret(childComplexity, args["input"].(secret.CreateSecretInput)), true - case "Mutation.updateUnleashInstance": - if e.ComplexityRoot.Mutation.UpdateUnleashInstance == nil { + case "Mutation.createServiceAccount": + if e.ComplexityRoot.Mutation.CreateServiceAccount == nil { break } - args, err := ec.field_Mutation_updateUnleashInstance_args(ctx, rawArgs) + args, err := ec.field_Mutation_createServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateUnleashInstance(childComplexity, args["input"].(unleash.UpdateUnleashInstanceInput)), true + return e.ComplexityRoot.Mutation.CreateServiceAccount(childComplexity, args["input"].(serviceaccount.CreateServiceAccountInput)), true - case "Mutation.updateValkey": - if e.ComplexityRoot.Mutation.UpdateValkey == nil { + case "Mutation.createServiceAccountToken": + if e.ComplexityRoot.Mutation.CreateServiceAccountToken == nil { break } - args, err := ec.field_Mutation_updateValkey_args(ctx, rawArgs) + args, err := ec.field_Mutation_createServiceAccountToken_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateValkey(childComplexity, args["input"].(valkey.UpdateValkeyInput)), true + return e.ComplexityRoot.Mutation.CreateServiceAccountToken(childComplexity, args["input"].(serviceaccount.CreateServiceAccountTokenInput)), true - case "Mutation.viewSecretValues": - if e.ComplexityRoot.Mutation.ViewSecretValues == nil { + case "Mutation.createTeam": + if e.ComplexityRoot.Mutation.CreateTeam == nil { break } - args, err := ec.field_Mutation_viewSecretValues_args(ctx, rawArgs) + args, err := ec.field_Mutation_createTeam_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.ViewSecretValues(childComplexity, args["input"].(secret.ViewSecretValuesInput)), true + return e.ComplexityRoot.Mutation.CreateTeam(childComplexity, args["input"].(team.CreateTeamInput)), true - case "NetworkPolicy.inbound": - if e.ComplexityRoot.NetworkPolicy.Inbound == nil { + case "Mutation.createUnleashForTeam": + if e.ComplexityRoot.Mutation.CreateUnleashForTeam == nil { break } - return e.ComplexityRoot.NetworkPolicy.Inbound(childComplexity), true - - case "NetworkPolicy.outbound": - if e.ComplexityRoot.NetworkPolicy.Outbound == nil { - break + args, err := ec.field_Mutation_createUnleashForTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NetworkPolicy.Outbound(childComplexity), true + return e.ComplexityRoot.Mutation.CreateUnleashForTeam(childComplexity, args["input"].(unleash.CreateUnleashForTeamInput)), true - case "NetworkPolicyRule.mutual": - if e.ComplexityRoot.NetworkPolicyRule.Mutual == nil { + case "Mutation.createValkey": + if e.ComplexityRoot.Mutation.CreateValkey == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.Mutual(childComplexity), true - - case "NetworkPolicyRule.targetTeam": - if e.ComplexityRoot.NetworkPolicyRule.TargetTeam == nil { - break + args, err := ec.field_Mutation_createValkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NetworkPolicyRule.TargetTeam(childComplexity), true + return e.ComplexityRoot.Mutation.CreateValkey(childComplexity, args["input"].(valkey.CreateValkeyInput)), true - case "NetworkPolicyRule.targetTeamSlug": - if e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug == nil { + case "Mutation.createValkeyCredentials": + if e.ComplexityRoot.Mutation.CreateValkeyCredentials == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug(childComplexity), true - - case "NetworkPolicyRule.targetWorkload": - if e.ComplexityRoot.NetworkPolicyRule.TargetWorkload == nil { - break + args, err := ec.field_Mutation_createValkeyCredentials_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NetworkPolicyRule.TargetWorkload(childComplexity), true + return e.ComplexityRoot.Mutation.CreateValkeyCredentials(childComplexity, args["input"].(aivencredentials.CreateValkeyCredentialsInput)), true - case "NetworkPolicyRule.targetWorkloadName": - if e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName == nil { + case "Mutation.deleteApplication": + if e.ComplexityRoot.Mutation.DeleteApplication == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName(childComplexity), true - - case "NoRunningInstancesIssue.id": - if e.ComplexityRoot.NoRunningInstancesIssue.ID == nil { - break + args, err := ec.field_Mutation_deleteApplication_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NoRunningInstancesIssue.ID(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteApplication(childComplexity, args["input"].(application.DeleteApplicationInput)), true - case "NoRunningInstancesIssue.message": - if e.ComplexityRoot.NoRunningInstancesIssue.Message == nil { + case "Mutation.deleteConfig": + if e.ComplexityRoot.Mutation.DeleteConfig == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.Message(childComplexity), true - - case "NoRunningInstancesIssue.severity": - if e.ComplexityRoot.NoRunningInstancesIssue.Severity == nil { - break + args, err := ec.field_Mutation_deleteConfig_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NoRunningInstancesIssue.Severity(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteConfig(childComplexity, args["input"].(configmap.DeleteConfigInput)), true - case "NoRunningInstancesIssue.teamEnvironment": - if e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment == nil { + case "Mutation.deleteJob": + if e.ComplexityRoot.Mutation.DeleteJob == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment(childComplexity), true - - case "NoRunningInstancesIssue.workload": - if e.ComplexityRoot.NoRunningInstancesIssue.Workload == nil { - break + args, err := ec.field_Mutation_deleteJob_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NoRunningInstancesIssue.Workload(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteJob(childComplexity, args["input"].(job.DeleteJobInput)), true - case "OpenSearch.access": - if e.ComplexityRoot.OpenSearch.Access == nil { + case "Mutation.deleteOpenSearch": + if e.ComplexityRoot.Mutation.DeleteOpenSearch == nil { break } - args, err := ec.field_OpenSearch_access_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteOpenSearch_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchAccessOrder)), true + return e.ComplexityRoot.Mutation.DeleteOpenSearch(childComplexity, args["input"].(opensearch.DeleteOpenSearchInput)), true - case "OpenSearch.activityLog": - if e.ComplexityRoot.OpenSearch.ActivityLog == nil { + case "Mutation.deleteSecret": + if e.ComplexityRoot.Mutation.DeleteSecret == nil { break } - args, err := ec.field_OpenSearch_activityLog_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteSecret_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Mutation.DeleteSecret(childComplexity, args["input"].(secret.DeleteSecretInput)), true - case "OpenSearch.cost": - if e.ComplexityRoot.OpenSearch.Cost == nil { + case "Mutation.deleteServiceAccount": + if e.ComplexityRoot.Mutation.DeleteServiceAccount == nil { break } - return e.ComplexityRoot.OpenSearch.Cost(childComplexity), true - - case "OpenSearch.environment": - if e.ComplexityRoot.OpenSearch.Environment == nil { - break + args, err := ec.field_Mutation_deleteServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Environment(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteServiceAccount(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountInput)), true - case "OpenSearch.id": - if e.ComplexityRoot.OpenSearch.ID == nil { + case "Mutation.deleteServiceAccountToken": + if e.ComplexityRoot.Mutation.DeleteServiceAccountToken == nil { break } - return e.ComplexityRoot.OpenSearch.ID(childComplexity), true + args, err := ec.field_Mutation_deleteServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearch.issues": - if e.ComplexityRoot.OpenSearch.Issues == nil { + return e.ComplexityRoot.Mutation.DeleteServiceAccountToken(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountTokenInput)), true + + case "Mutation.deleteUnleashInstance": + if e.ComplexityRoot.Mutation.DeleteUnleashInstance == nil { break } - args, err := ec.field_OpenSearch_issues_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteUnleashInstance_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.Mutation.DeleteUnleashInstance(childComplexity, args["input"].(unleash.DeleteUnleashInstanceInput)), true - case "OpenSearch.maintenance": - if e.ComplexityRoot.OpenSearch.Maintenance == nil { + case "Mutation.deleteValkey": + if e.ComplexityRoot.Mutation.DeleteValkey == nil { break } - return e.ComplexityRoot.OpenSearch.Maintenance(childComplexity), true - - case "OpenSearch.memory": - if e.ComplexityRoot.OpenSearch.Memory == nil { - break + args, err := ec.field_Mutation_deleteValkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Memory(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteValkey(childComplexity, args["input"].(valkey.DeleteValkeyInput)), true - case "OpenSearch.name": - if e.ComplexityRoot.OpenSearch.Name == nil { + case "Mutation.disableReconciler": + if e.ComplexityRoot.Mutation.DisableReconciler == nil { break } - return e.ComplexityRoot.OpenSearch.Name(childComplexity), true - - case "OpenSearch.state": - if e.ComplexityRoot.OpenSearch.State == nil { - break + args, err := ec.field_Mutation_disableReconciler_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.State(childComplexity), true + return e.ComplexityRoot.Mutation.DisableReconciler(childComplexity, args["input"].(reconciler.DisableReconcilerInput)), true - case "OpenSearch.storageGB": - if e.ComplexityRoot.OpenSearch.StorageGB == nil { + case "Mutation.enableReconciler": + if e.ComplexityRoot.Mutation.EnableReconciler == nil { break } - return e.ComplexityRoot.OpenSearch.StorageGB(childComplexity), true - - case "OpenSearch.team": - if e.ComplexityRoot.OpenSearch.Team == nil { - break + args, err := ec.field_Mutation_enableReconciler_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Team(childComplexity), true + return e.ComplexityRoot.Mutation.EnableReconciler(childComplexity, args["input"].(reconciler.EnableReconcilerInput)), true - case "OpenSearch.teamEnvironment": - if e.ComplexityRoot.OpenSearch.TeamEnvironment == nil { + case "Mutation.grantPostgresAccess": + if e.ComplexityRoot.Mutation.GrantPostgresAccess == nil { break } - return e.ComplexityRoot.OpenSearch.TeamEnvironment(childComplexity), true - - case "OpenSearch.terminationProtection": - if e.ComplexityRoot.OpenSearch.TerminationProtection == nil { - break + args, err := ec.field_Mutation_grantPostgresAccess_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.TerminationProtection(childComplexity), true + return e.ComplexityRoot.Mutation.GrantPostgresAccess(childComplexity, args["input"].(postgres.GrantPostgresAccessInput)), true - case "OpenSearch.tier": - if e.ComplexityRoot.OpenSearch.Tier == nil { + case "Mutation.removeConfigValue": + if e.ComplexityRoot.Mutation.RemoveConfigValue == nil { break } - return e.ComplexityRoot.OpenSearch.Tier(childComplexity), true - - case "OpenSearch.version": - if e.ComplexityRoot.OpenSearch.Version == nil { - break + args, err := ec.field_Mutation_removeConfigValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Version(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveConfigValue(childComplexity, args["input"].(configmap.RemoveConfigValueInput)), true - case "OpenSearch.workload": - if e.ComplexityRoot.OpenSearch.Workload == nil { + case "Mutation.removeRepositoryFromTeam": + if e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam == nil { break } - return e.ComplexityRoot.OpenSearch.Workload(childComplexity), true - - case "OpenSearchAccess.access": - if e.ComplexityRoot.OpenSearchAccess.Access == nil { - break + args, err := ec.field_Mutation_removeRepositoryFromTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccess.Access(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam(childComplexity, args["input"].(repository.RemoveRepositoryFromTeamInput)), true - case "OpenSearchAccess.workload": - if e.ComplexityRoot.OpenSearchAccess.Workload == nil { + case "Mutation.removeSecretValue": + if e.ComplexityRoot.Mutation.RemoveSecretValue == nil { break } - return e.ComplexityRoot.OpenSearchAccess.Workload(childComplexity), true - - case "OpenSearchAccessConnection.edges": - if e.ComplexityRoot.OpenSearchAccessConnection.Edges == nil { - break + args, err := ec.field_Mutation_removeSecretValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccessConnection.Edges(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveSecretValue(childComplexity, args["input"].(secret.RemoveSecretValueInput)), true - case "OpenSearchAccessConnection.nodes": - if e.ComplexityRoot.OpenSearchAccessConnection.Nodes == nil { + case "Mutation.removeTeamMember": + if e.ComplexityRoot.Mutation.RemoveTeamMember == nil { break } - return e.ComplexityRoot.OpenSearchAccessConnection.Nodes(childComplexity), true - - case "OpenSearchAccessConnection.pageInfo": - if e.ComplexityRoot.OpenSearchAccessConnection.PageInfo == nil { - break + args, err := ec.field_Mutation_removeTeamMember_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccessConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveTeamMember(childComplexity, args["input"].(team.RemoveTeamMemberInput)), true - case "OpenSearchAccessEdge.cursor": - if e.ComplexityRoot.OpenSearchAccessEdge.Cursor == nil { + case "Mutation.requestTeamDeletion": + if e.ComplexityRoot.Mutation.RequestTeamDeletion == nil { break } - return e.ComplexityRoot.OpenSearchAccessEdge.Cursor(childComplexity), true - - case "OpenSearchAccessEdge.node": - if e.ComplexityRoot.OpenSearchAccessEdge.Node == nil { - break + args, err := ec.field_Mutation_requestTeamDeletion_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccessEdge.Node(childComplexity), true + return e.ComplexityRoot.Mutation.RequestTeamDeletion(childComplexity, args["input"].(team.RequestTeamDeletionInput)), true - case "OpenSearchConnection.edges": - if e.ComplexityRoot.OpenSearchConnection.Edges == nil { + case "Mutation.restartApplication": + if e.ComplexityRoot.Mutation.RestartApplication == nil { break } - return e.ComplexityRoot.OpenSearchConnection.Edges(childComplexity), true - - case "OpenSearchConnection.nodes": - if e.ComplexityRoot.OpenSearchConnection.Nodes == nil { - break + args, err := ec.field_Mutation_restartApplication_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Mutation.RestartApplication(childComplexity, args["input"].(application.RestartApplicationInput)), true - case "OpenSearchConnection.pageInfo": - if e.ComplexityRoot.OpenSearchConnection.PageInfo == nil { + case "Mutation.revokeRoleFromServiceAccount": + if e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount == nil { break } - return e.ComplexityRoot.OpenSearchConnection.PageInfo(childComplexity), true - - case "OpenSearchCost.sum": - if e.ComplexityRoot.OpenSearchCost.Sum == nil { - break + args, err := ec.field_Mutation_revokeRoleFromServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCost.Sum(childComplexity), true + return e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount(childComplexity, args["input"].(serviceaccount.RevokeRoleFromServiceAccountInput)), true - case "OpenSearchCreatedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor == nil { + case "Mutation.revokeTeamAccessToUnleash": + if e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Mutation_revokeTeamAccessToUnleash_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash(childComplexity, args["input"].(unleash.RevokeTeamAccessToUnleashInput)), true - case "OpenSearchCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName == nil { + case "Mutation.setTeamMemberRole": + if e.ComplexityRoot.Mutation.SetTeamMemberRole == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID == nil { - break + args, err := ec.field_Mutation_setTeamMemberRole_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Mutation.SetTeamMemberRole(childComplexity, args["input"].(team.SetTeamMemberRoleInput)), true - case "OpenSearchCreatedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message == nil { + case "Mutation.startOpenSearchMaintenance": + if e.ComplexityRoot.Mutation.StartOpenSearchMaintenance == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_Mutation_startOpenSearchMaintenance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Mutation.StartOpenSearchMaintenance(childComplexity, args["input"].(servicemaintenance.StartOpenSearchMaintenanceInput)), true - case "OpenSearchCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType == nil { + case "Mutation.startValkeyMaintenance": + if e.ComplexityRoot.Mutation.StartValkeyMaintenance == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_Mutation_startValkeyMaintenance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Mutation.StartValkeyMaintenance(childComplexity, args["input"].(servicemaintenance.StartValkeyMaintenanceInput)), true - case "OpenSearchCredentials.host": - if e.ComplexityRoot.OpenSearchCredentials.Host == nil { + case "Mutation.triggerJob": + if e.ComplexityRoot.Mutation.TriggerJob == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Host(childComplexity), true - - case "OpenSearchCredentials.password": - if e.ComplexityRoot.OpenSearchCredentials.Password == nil { - break + args, err := ec.field_Mutation_triggerJob_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCredentials.Password(childComplexity), true + return e.ComplexityRoot.Mutation.TriggerJob(childComplexity, args["input"].(job.TriggerJobInput)), true - case "OpenSearchCredentials.port": - if e.ComplexityRoot.OpenSearchCredentials.Port == nil { + case "Mutation.updateConfigValue": + if e.ComplexityRoot.Mutation.UpdateConfigValue == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Port(childComplexity), true - - case "OpenSearchCredentials.uri": - if e.ComplexityRoot.OpenSearchCredentials.URI == nil { - break + args, err := ec.field_Mutation_updateConfigValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCredentials.URI(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateConfigValue(childComplexity, args["input"].(configmap.UpdateConfigValueInput)), true - case "OpenSearchCredentials.username": - if e.ComplexityRoot.OpenSearchCredentials.Username == nil { + case "Mutation.updateImageVulnerability": + if e.ComplexityRoot.Mutation.UpdateImageVulnerability == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Username(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Mutation_updateImageVulnerability_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateImageVulnerability(childComplexity, args["input"].(vulnerability.UpdateImageVulnerabilityInput)), true - case "OpenSearchDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt == nil { + case "Mutation.updateOpenSearch": + if e.ComplexityRoot.Mutation.UpdateOpenSearch == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Mutation_updateOpenSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateOpenSearch(childComplexity, args["input"].(opensearch.UpdateOpenSearchInput)), true - case "OpenSearchDeletedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID == nil { + case "Mutation.updateSecretValue": + if e.ComplexityRoot.Mutation.UpdateSecretValue == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message == nil { - break + args, err := ec.field_Mutation_updateSecretValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateSecretValue(childComplexity, args["input"].(secret.UpdateSecretValueInput)), true - case "OpenSearchDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName == nil { + case "Mutation.updateServiceAccount": + if e.ComplexityRoot.Mutation.UpdateServiceAccount == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Mutation_updateServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateServiceAccount(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountInput)), true - case "OpenSearchDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug == nil { + case "Mutation.updateServiceAccountToken": + if e.ComplexityRoot.Mutation.UpdateServiceAccountToken == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug(childComplexity), true - - case "OpenSearchEdge.cursor": - if e.ComplexityRoot.OpenSearchEdge.Cursor == nil { - break + args, err := ec.field_Mutation_updateServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateServiceAccountToken(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountTokenInput)), true - case "OpenSearchEdge.node": - if e.ComplexityRoot.OpenSearchEdge.Node == nil { + case "Mutation.updateTeam": + if e.ComplexityRoot.Mutation.UpdateTeam == nil { break } - return e.ComplexityRoot.OpenSearchEdge.Node(childComplexity), true - - case "OpenSearchIssue.event": - if e.ComplexityRoot.OpenSearchIssue.Event == nil { - break + args, err := ec.field_Mutation_updateTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchIssue.Event(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateTeam(childComplexity, args["input"].(team.UpdateTeamInput)), true - case "OpenSearchIssue.id": - if e.ComplexityRoot.OpenSearchIssue.ID == nil { + case "Mutation.updateTeamEnvironment": + if e.ComplexityRoot.Mutation.UpdateTeamEnvironment == nil { break } - return e.ComplexityRoot.OpenSearchIssue.ID(childComplexity), true - - case "OpenSearchIssue.message": - if e.ComplexityRoot.OpenSearchIssue.Message == nil { - break + args, err := ec.field_Mutation_updateTeamEnvironment_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchIssue.Message(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateTeamEnvironment(childComplexity, args["input"].(team.UpdateTeamEnvironmentInput)), true - case "OpenSearchIssue.openSearch": - if e.ComplexityRoot.OpenSearchIssue.OpenSearch == nil { + case "Mutation.updateUnleashInstance": + if e.ComplexityRoot.Mutation.UpdateUnleashInstance == nil { break } - return e.ComplexityRoot.OpenSearchIssue.OpenSearch(childComplexity), true - - case "OpenSearchIssue.severity": - if e.ComplexityRoot.OpenSearchIssue.Severity == nil { - break + args, err := ec.field_Mutation_updateUnleashInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchIssue.Severity(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateUnleashInstance(childComplexity, args["input"].(unleash.UpdateUnleashInstanceInput)), true - case "OpenSearchIssue.teamEnvironment": - if e.ComplexityRoot.OpenSearchIssue.TeamEnvironment == nil { + case "Mutation.updateValkey": + if e.ComplexityRoot.Mutation.UpdateValkey == nil { break } - return e.ComplexityRoot.OpenSearchIssue.TeamEnvironment(childComplexity), true + args, err := ec.field_Mutation_updateValkey_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearchMaintenance.updates": - if e.ComplexityRoot.OpenSearchMaintenance.Updates == nil { + return e.ComplexityRoot.Mutation.UpdateValkey(childComplexity, args["input"].(valkey.UpdateValkeyInput)), true + + case "Mutation.viewSecretValues": + if e.ComplexityRoot.Mutation.ViewSecretValues == nil { break } - args, err := ec.field_OpenSearchMaintenance_updates_args(ctx, rawArgs) + args, err := ec.field_Mutation_viewSecretValues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearchMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Mutation.ViewSecretValues(childComplexity, args["input"].(secret.ViewSecretValuesInput)), true - case "OpenSearchMaintenance.window": - if e.ComplexityRoot.OpenSearchMaintenance.Window == nil { + case "NetworkPolicy.inbound": + if e.ComplexityRoot.NetworkPolicy.Inbound == nil { break } - return e.ComplexityRoot.OpenSearchMaintenance.Window(childComplexity), true + return e.ComplexityRoot.NetworkPolicy.Inbound(childComplexity), true - case "OpenSearchMaintenanceUpdate.deadline": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline == nil { + case "NetworkPolicy.outbound": + if e.ComplexityRoot.NetworkPolicy.Outbound == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline(childComplexity), true + return e.ComplexityRoot.NetworkPolicy.Outbound(childComplexity), true - case "OpenSearchMaintenanceUpdate.description": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description == nil { + case "NetworkPolicyRule.mutual": + if e.ComplexityRoot.NetworkPolicyRule.Mutual == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.Mutual(childComplexity), true - case "OpenSearchMaintenanceUpdate.startAt": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt == nil { + case "NetworkPolicyRule.targetTeam": + if e.ComplexityRoot.NetworkPolicyRule.TargetTeam == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetTeam(childComplexity), true - case "OpenSearchMaintenanceUpdate.title": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title == nil { + case "NetworkPolicyRule.targetTeamSlug": + if e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.edges": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges == nil { + case "NetworkPolicyRule.targetWorkload": + if e.ComplexityRoot.NetworkPolicyRule.TargetWorkload == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetWorkload(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.nodes": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes == nil { + case "NetworkPolicyRule.targetWorkloadName": + if e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.pageInfo": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo == nil { + case "NoRunningInstancesIssue.id": + if e.ComplexityRoot.NoRunningInstancesIssue.ID == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.ID(childComplexity), true - case "OpenSearchMaintenanceUpdateEdge.cursor": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor == nil { + case "NoRunningInstancesIssue.message": + if e.ComplexityRoot.NoRunningInstancesIssue.Message == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.Message(childComplexity), true - case "OpenSearchMaintenanceUpdateEdge.node": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node == nil { + case "NoRunningInstancesIssue.severity": + if e.ComplexityRoot.NoRunningInstancesIssue.Severity == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.Severity(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor == nil { + case "NoRunningInstancesIssue.teamEnvironment": + if e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt == nil { + case "NoRunningInstancesIssue.workload": + if e.ComplexityRoot.NoRunningInstancesIssue.Workload == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.Workload(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.data": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data == nil { + case "OpenSearch.access": + if e.ComplexityRoot.OpenSearch.Access == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data(childComplexity), true - - case "OpenSearchUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_OpenSearch_access_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.OpenSearch.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchAccessOrder)), true - case "OpenSearchUpdatedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID == nil { + case "OpenSearch.activityLog": + if e.ComplexityRoot.OpenSearch.ActivityLog == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID(childComplexity), true - - case "OpenSearchUpdatedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message == nil { - break + args, err := ec.field_OpenSearch_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.OpenSearch.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "OpenSearchUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName == nil { + case "OpenSearch.cost": + if e.ComplexityRoot.OpenSearch.Cost == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.OpenSearch.Cost(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType == nil { + case "OpenSearch.environment": + if e.ComplexityRoot.OpenSearch.Environment == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.OpenSearch.Environment(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug == nil { + case "OpenSearch.id": + if e.ComplexityRoot.OpenSearch.ID == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.OpenSearch.ID(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields == nil { + case "OpenSearch.issues": + if e.ComplexityRoot.OpenSearch.Issues == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + args, err := ec.field_OpenSearch_issues_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field == nil { + return e.ComplexityRoot.OpenSearch.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + + case "OpenSearch.maintenance": + if e.ComplexityRoot.OpenSearch.Maintenance == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.OpenSearch.Maintenance(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "OpenSearch.memory": + if e.ComplexityRoot.OpenSearch.Memory == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.OpenSearch.Memory(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "OpenSearch.name": + if e.ComplexityRoot.OpenSearch.Name == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.OpenSearch.Name(childComplexity), true - case "OpenSearchVersion.actual": - if e.ComplexityRoot.OpenSearchVersion.Actual == nil { + case "OpenSearch.state": + if e.ComplexityRoot.OpenSearch.State == nil { break } - return e.ComplexityRoot.OpenSearchVersion.Actual(childComplexity), true + return e.ComplexityRoot.OpenSearch.State(childComplexity), true - case "OpenSearchVersion.desiredMajor": - if e.ComplexityRoot.OpenSearchVersion.DesiredMajor == nil { + case "OpenSearch.storageGB": + if e.ComplexityRoot.OpenSearch.StorageGB == nil { break } - return e.ComplexityRoot.OpenSearchVersion.DesiredMajor(childComplexity), true + return e.ComplexityRoot.OpenSearch.StorageGB(childComplexity), true - case "OutboundNetworkPolicy.external": - if e.ComplexityRoot.OutboundNetworkPolicy.External == nil { + case "OpenSearch.team": + if e.ComplexityRoot.OpenSearch.Team == nil { break } - return e.ComplexityRoot.OutboundNetworkPolicy.External(childComplexity), true + return e.ComplexityRoot.OpenSearch.Team(childComplexity), true - case "OutboundNetworkPolicy.rules": - if e.ComplexityRoot.OutboundNetworkPolicy.Rules == nil { + case "OpenSearch.teamEnvironment": + if e.ComplexityRoot.OpenSearch.TeamEnvironment == nil { break } - return e.ComplexityRoot.OutboundNetworkPolicy.Rules(childComplexity), true + return e.ComplexityRoot.OpenSearch.TeamEnvironment(childComplexity), true - case "PageInfo.endCursor": - if e.ComplexityRoot.PageInfo.EndCursor == nil { + case "OpenSearch.terminationProtection": + if e.ComplexityRoot.OpenSearch.TerminationProtection == nil { break } - return e.ComplexityRoot.PageInfo.EndCursor(childComplexity), true + return e.ComplexityRoot.OpenSearch.TerminationProtection(childComplexity), true - case "PageInfo.hasNextPage": - if e.ComplexityRoot.PageInfo.HasNextPage == nil { + case "OpenSearch.tier": + if e.ComplexityRoot.OpenSearch.Tier == nil { break } - return e.ComplexityRoot.PageInfo.HasNextPage(childComplexity), true + return e.ComplexityRoot.OpenSearch.Tier(childComplexity), true - case "PageInfo.hasPreviousPage": - if e.ComplexityRoot.PageInfo.HasPreviousPage == nil { + case "OpenSearch.version": + if e.ComplexityRoot.OpenSearch.Version == nil { break } - return e.ComplexityRoot.PageInfo.HasPreviousPage(childComplexity), true + return e.ComplexityRoot.OpenSearch.Version(childComplexity), true - case "PageInfo.pageEnd": - if e.ComplexityRoot.PageInfo.PageEnd == nil { + case "OpenSearch.workload": + if e.ComplexityRoot.OpenSearch.Workload == nil { break } - return e.ComplexityRoot.PageInfo.PageEnd(childComplexity), true + return e.ComplexityRoot.OpenSearch.Workload(childComplexity), true - case "PageInfo.pageStart": - if e.ComplexityRoot.PageInfo.PageStart == nil { + case "OpenSearchAccess.access": + if e.ComplexityRoot.OpenSearchAccess.Access == nil { break } - return e.ComplexityRoot.PageInfo.PageStart(childComplexity), true + return e.ComplexityRoot.OpenSearchAccess.Access(childComplexity), true - case "PageInfo.startCursor": - if e.ComplexityRoot.PageInfo.StartCursor == nil { + case "OpenSearchAccess.workload": + if e.ComplexityRoot.OpenSearchAccess.Workload == nil { break } - return e.ComplexityRoot.PageInfo.StartCursor(childComplexity), true + return e.ComplexityRoot.OpenSearchAccess.Workload(childComplexity), true - case "PageInfo.totalCount": - if e.ComplexityRoot.PageInfo.TotalCount == nil { + case "OpenSearchAccessConnection.edges": + if e.ComplexityRoot.OpenSearchAccessConnection.Edges == nil { break } - return e.ComplexityRoot.PageInfo.TotalCount(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessConnection.Edges(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.actor": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor == nil { + case "OpenSearchAccessConnection.nodes": + if e.ComplexityRoot.OpenSearchAccessConnection.Nodes == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessConnection.Nodes(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.createdAt": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt == nil { + case "OpenSearchAccessConnection.pageInfo": + if e.ComplexityRoot.OpenSearchAccessConnection.PageInfo == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessConnection.PageInfo(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.data": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data == nil { + case "OpenSearchAccessEdge.cursor": + if e.ComplexityRoot.OpenSearchAccessEdge.Cursor == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessEdge.Cursor(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.environmentName": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName == nil { + case "OpenSearchAccessEdge.node": + if e.ComplexityRoot.OpenSearchAccessEdge.Node == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessEdge.Node(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.id": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID == nil { + case "OpenSearchConnection.edges": + if e.ComplexityRoot.OpenSearchConnection.Edges == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchConnection.Edges(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.message": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message == nil { + case "OpenSearchConnection.nodes": + if e.ComplexityRoot.OpenSearchConnection.Nodes == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.OpenSearchConnection.Nodes(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.resourceName": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName == nil { + case "OpenSearchConnection.pageInfo": + if e.ComplexityRoot.OpenSearchConnection.PageInfo == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.OpenSearchConnection.PageInfo(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.resourceType": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType == nil { + case "OpenSearchCost.sum": + if e.ComplexityRoot.OpenSearchCost.Sum == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.OpenSearchCost.Sum(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.teamSlug": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug == nil { + case "OpenSearchCreatedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor(childComplexity), true - case "PostgresGrantAccessActivityLogEntryData.grantee": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee == nil { + case "OpenSearchCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "PostgresGrantAccessActivityLogEntryData.until": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until == nil { + case "OpenSearchCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "PostgresInstance.audit": - if e.ComplexityRoot.PostgresInstance.Audit == nil { + case "OpenSearchCreatedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.PostgresInstance.Audit(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID(childComplexity), true - case "PostgresInstance.environment": - if e.ComplexityRoot.PostgresInstance.Environment == nil { + case "OpenSearchCreatedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.PostgresInstance.Environment(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message(childComplexity), true - case "PostgresInstance.highAvailability": - if e.ComplexityRoot.PostgresInstance.HighAvailability == nil { + case "OpenSearchCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.PostgresInstance.HighAvailability(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName(childComplexity), true - case "PostgresInstance.id": - if e.ComplexityRoot.PostgresInstance.ID == nil { + case "OpenSearchCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.PostgresInstance.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType(childComplexity), true - case "PostgresInstance.maintenanceWindow": - if e.ComplexityRoot.PostgresInstance.MaintenanceWindow == nil { + case "OpenSearchCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.PostgresInstance.MaintenanceWindow(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "PostgresInstance.majorVersion": - if e.ComplexityRoot.PostgresInstance.MajorVersion == nil { + case "OpenSearchCredentials.host": + if e.ComplexityRoot.OpenSearchCredentials.Host == nil { break } - return e.ComplexityRoot.PostgresInstance.MajorVersion(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Host(childComplexity), true - case "PostgresInstance.name": - if e.ComplexityRoot.PostgresInstance.Name == nil { + case "OpenSearchCredentials.password": + if e.ComplexityRoot.OpenSearchCredentials.Password == nil { break } - return e.ComplexityRoot.PostgresInstance.Name(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Password(childComplexity), true - case "PostgresInstance.resources": - if e.ComplexityRoot.PostgresInstance.Resources == nil { + case "OpenSearchCredentials.port": + if e.ComplexityRoot.OpenSearchCredentials.Port == nil { break } - return e.ComplexityRoot.PostgresInstance.Resources(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Port(childComplexity), true - case "PostgresInstance.state": - if e.ComplexityRoot.PostgresInstance.State == nil { + case "OpenSearchCredentials.uri": + if e.ComplexityRoot.OpenSearchCredentials.URI == nil { break } - return e.ComplexityRoot.PostgresInstance.State(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.URI(childComplexity), true - case "PostgresInstance.team": - if e.ComplexityRoot.PostgresInstance.Team == nil { + case "OpenSearchCredentials.username": + if e.ComplexityRoot.OpenSearchCredentials.Username == nil { break } - return e.ComplexityRoot.PostgresInstance.Team(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Username(childComplexity), true - case "PostgresInstance.teamEnvironment": - if e.ComplexityRoot.PostgresInstance.TeamEnvironment == nil { + case "OpenSearchDeletedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.PostgresInstance.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor(childComplexity), true - case "PostgresInstance.workloads": - if e.ComplexityRoot.PostgresInstance.Workloads == nil { + case "OpenSearchDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_PostgresInstance_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt(childComplexity), true + + case "OpenSearchDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName == nil { + break } - return e.ComplexityRoot.PostgresInstance.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "PostgresInstanceAudit.enabled": - if e.ComplexityRoot.PostgresInstanceAudit.Enabled == nil { + case "OpenSearchDeletedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.Enabled(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID(childComplexity), true - case "PostgresInstanceAudit.statementClasses": - if e.ComplexityRoot.PostgresInstanceAudit.StatementClasses == nil { + case "OpenSearchDeletedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.StatementClasses(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message(childComplexity), true - case "PostgresInstanceAudit.url": - if e.ComplexityRoot.PostgresInstanceAudit.URL == nil { + case "OpenSearchDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.URL(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName(childComplexity), true - case "PostgresInstanceConnection.edges": - if e.ComplexityRoot.PostgresInstanceConnection.Edges == nil { + case "OpenSearchDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType(childComplexity), true - case "PostgresInstanceConnection.nodes": - if e.ComplexityRoot.PostgresInstanceConnection.Nodes == nil { + case "OpenSearchDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "PostgresInstanceConnection.pageInfo": - if e.ComplexityRoot.PostgresInstanceConnection.PageInfo == nil { + case "OpenSearchEdge.cursor": + if e.ComplexityRoot.OpenSearchEdge.Cursor == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.OpenSearchEdge.Cursor(childComplexity), true - case "PostgresInstanceEdge.cursor": - if e.ComplexityRoot.PostgresInstanceEdge.Cursor == nil { + case "OpenSearchEdge.node": + if e.ComplexityRoot.OpenSearchEdge.Node == nil { break } - return e.ComplexityRoot.PostgresInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.OpenSearchEdge.Node(childComplexity), true - case "PostgresInstanceEdge.node": - if e.ComplexityRoot.PostgresInstanceEdge.Node == nil { + case "OpenSearchIssue.event": + if e.ComplexityRoot.OpenSearchIssue.Event == nil { break } - return e.ComplexityRoot.PostgresInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Event(childComplexity), true - case "PostgresInstanceMaintenanceWindow.day": - if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day == nil { + case "OpenSearchIssue.id": + if e.ComplexityRoot.OpenSearchIssue.ID == nil { break } - return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.ID(childComplexity), true - case "PostgresInstanceMaintenanceWindow.hour": - if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour == nil { + case "OpenSearchIssue.message": + if e.ComplexityRoot.OpenSearchIssue.Message == nil { break } - return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Message(childComplexity), true - case "PostgresInstanceResources.cpu": - if e.ComplexityRoot.PostgresInstanceResources.CPU == nil { + case "OpenSearchIssue.openSearch": + if e.ComplexityRoot.OpenSearchIssue.OpenSearch == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.CPU(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.OpenSearch(childComplexity), true - case "PostgresInstanceResources.diskSize": - if e.ComplexityRoot.PostgresInstanceResources.DiskSize == nil { + case "OpenSearchIssue.severity": + if e.ComplexityRoot.OpenSearchIssue.Severity == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.DiskSize(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Severity(childComplexity), true - case "PostgresInstanceResources.memory": - if e.ComplexityRoot.PostgresInstanceResources.Memory == nil { + case "OpenSearchIssue.teamEnvironment": + if e.ComplexityRoot.OpenSearchIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.Memory(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.TeamEnvironment(childComplexity), true - case "Price.value": - if e.ComplexityRoot.Price.Value == nil { + case "OpenSearchMaintenance.updates": + if e.ComplexityRoot.OpenSearchMaintenance.Updates == nil { break } - return e.ComplexityRoot.Price.Value(childComplexity), true + args, err := ec.field_OpenSearchMaintenance_updates_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "PrometheusAlarm.action": - if e.ComplexityRoot.PrometheusAlarm.Action == nil { + return e.ComplexityRoot.OpenSearchMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "OpenSearchMaintenance.window": + if e.ComplexityRoot.OpenSearchMaintenance.Window == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Action(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenance.Window(childComplexity), true - case "PrometheusAlarm.consequence": - if e.ComplexityRoot.PrometheusAlarm.Consequence == nil { + case "OpenSearchMaintenanceUpdate.deadline": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Consequence(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline(childComplexity), true - case "PrometheusAlarm.since": - if e.ComplexityRoot.PrometheusAlarm.Since == nil { + case "OpenSearchMaintenanceUpdate.description": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Since(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description(childComplexity), true - case "PrometheusAlarm.state": - if e.ComplexityRoot.PrometheusAlarm.State == nil { + case "OpenSearchMaintenanceUpdate.startAt": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt == nil { break } - return e.ComplexityRoot.PrometheusAlarm.State(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt(childComplexity), true - case "PrometheusAlarm.summary": - if e.ComplexityRoot.PrometheusAlarm.Summary == nil { + case "OpenSearchMaintenanceUpdate.title": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Summary(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title(childComplexity), true - case "PrometheusAlarm.value": - if e.ComplexityRoot.PrometheusAlarm.Value == nil { + case "OpenSearchMaintenanceUpdateConnection.edges": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Value(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges(childComplexity), true - case "PrometheusAlert.alarms": - if e.ComplexityRoot.PrometheusAlert.Alarms == nil { + case "OpenSearchMaintenanceUpdateConnection.nodes": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes == nil { break } - return e.ComplexityRoot.PrometheusAlert.Alarms(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes(childComplexity), true - case "PrometheusAlert.duration": - if e.ComplexityRoot.PrometheusAlert.Duration == nil { + case "OpenSearchMaintenanceUpdateConnection.pageInfo": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo == nil { break } - return e.ComplexityRoot.PrometheusAlert.Duration(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo(childComplexity), true - case "PrometheusAlert.id": - if e.ComplexityRoot.PrometheusAlert.ID == nil { + case "OpenSearchMaintenanceUpdateEdge.cursor": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor == nil { break } - return e.ComplexityRoot.PrometheusAlert.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor(childComplexity), true - case "PrometheusAlert.name": - if e.ComplexityRoot.PrometheusAlert.Name == nil { + case "OpenSearchMaintenanceUpdateEdge.node": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node == nil { break } - return e.ComplexityRoot.PrometheusAlert.Name(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node(childComplexity), true - case "PrometheusAlert.query": - if e.ComplexityRoot.PrometheusAlert.Query == nil { + case "OpenSearchUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.PrometheusAlert.Query(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor(childComplexity), true - case "PrometheusAlert.ruleGroup": - if e.ComplexityRoot.PrometheusAlert.RuleGroup == nil { + case "OpenSearchUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.PrometheusAlert.RuleGroup(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "PrometheusAlert.state": - if e.ComplexityRoot.PrometheusAlert.State == nil { + case "OpenSearchUpdatedActivityLogEntry.data": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.PrometheusAlert.State(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data(childComplexity), true - case "PrometheusAlert.team": - if e.ComplexityRoot.PrometheusAlert.Team == nil { + case "OpenSearchUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.PrometheusAlert.Team(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "PrometheusAlert.teamEnvironment": - if e.ComplexityRoot.PrometheusAlert.TeamEnvironment == nil { + case "OpenSearchUpdatedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.PrometheusAlert.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID(childComplexity), true - case "Query.cve": - if e.ComplexityRoot.Query.CVE == nil { + case "OpenSearchUpdatedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message == nil { break } - args, err := ec.field_Query_cve_args(ctx, rawArgs) - if err != nil { - return 0, false - } + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message(childComplexity), true - return e.ComplexityRoot.Query.CVE(childComplexity, args["identifier"].(string)), true - - case "Query.costMonthlySummary": - if e.ComplexityRoot.Query.CostMonthlySummary == nil { + case "OpenSearchUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Query_costMonthlySummary_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType == nil { + break } - return e.ComplexityRoot.Query.CostMonthlySummary(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "Query.currentUnitPrices": - if e.ComplexityRoot.Query.CurrentUnitPrices == nil { + case "OpenSearchUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.Query.CurrentUnitPrices(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "Query.cves": - if e.ComplexityRoot.Query.Cves == nil { + case "OpenSearchUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields == nil { break } - args, err := ec.field_Query_cves_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field == nil { + break } - return e.ComplexityRoot.Query.Cves(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.CVEOrder)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "Query.deployments": - if e.ComplexityRoot.Query.Deployments == nil { + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - args, err := ec.field_Query_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + break } - return e.ComplexityRoot.Query.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*deployment.DeploymentOrder), args["filter"].(*deployment.DeploymentFilter)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "Query.environment": - if e.ComplexityRoot.Query.Environment == nil { + case "OpenSearchVersion.actual": + if e.ComplexityRoot.OpenSearchVersion.Actual == nil { break } - args, err := ec.field_Query_environment_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchVersion.Actual(childComplexity), true + + case "OpenSearchVersion.desiredMajor": + if e.ComplexityRoot.OpenSearchVersion.DesiredMajor == nil { + break } - return e.ComplexityRoot.Query.Environment(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.OpenSearchVersion.DesiredMajor(childComplexity), true - case "Query.environments": - if e.ComplexityRoot.Query.Environments == nil { + case "OutboundNetworkPolicy.external": + if e.ComplexityRoot.OutboundNetworkPolicy.External == nil { break } - args, err := ec.field_Query_environments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OutboundNetworkPolicy.External(childComplexity), true + + case "OutboundNetworkPolicy.rules": + if e.ComplexityRoot.OutboundNetworkPolicy.Rules == nil { + break } - return e.ComplexityRoot.Query.Environments(childComplexity, args["orderBy"].(*environment.EnvironmentOrder)), true + return e.ComplexityRoot.OutboundNetworkPolicy.Rules(childComplexity), true - case "Query.features": - if e.ComplexityRoot.Query.Features == nil { + case "PageInfo.endCursor": + if e.ComplexityRoot.PageInfo.EndCursor == nil { break } - return e.ComplexityRoot.Query.Features(childComplexity), true + return e.ComplexityRoot.PageInfo.EndCursor(childComplexity), true - case "Query.imageVulnerabilityHistory": - if e.ComplexityRoot.Query.ImageVulnerabilityHistory == nil { + case "PageInfo.hasNextPage": + if e.ComplexityRoot.PageInfo.HasNextPage == nil { break } - args, err := ec.field_Query_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.HasNextPage(childComplexity), true + + case "PageInfo.hasPreviousPage": + if e.ComplexityRoot.PageInfo.HasPreviousPage == nil { + break } - return e.ComplexityRoot.Query.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.PageInfo.HasPreviousPage(childComplexity), true - case "Query.me": - if e.ComplexityRoot.Query.Me == nil { + case "PageInfo.pageEnd": + if e.ComplexityRoot.PageInfo.PageEnd == nil { break } - return e.ComplexityRoot.Query.Me(childComplexity), true + return e.ComplexityRoot.PageInfo.PageEnd(childComplexity), true - case "Query.node": - if e.ComplexityRoot.Query.Node == nil { + case "PageInfo.pageStart": + if e.ComplexityRoot.PageInfo.PageStart == nil { break } - args, err := ec.field_Query_node_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.PageStart(childComplexity), true + + case "PageInfo.startCursor": + if e.ComplexityRoot.PageInfo.StartCursor == nil { + break } - return e.ComplexityRoot.Query.Node(childComplexity, args["id"].(ident.Ident)), true + return e.ComplexityRoot.PageInfo.StartCursor(childComplexity), true - case "Query.reconcilers": - if e.ComplexityRoot.Query.Reconcilers == nil { + case "PageInfo.totalCount": + if e.ComplexityRoot.PageInfo.TotalCount == nil { break } - args, err := ec.field_Query_reconcilers_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.TotalCount(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.actor": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Query.Reconcilers(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor(childComplexity), true - case "Query.roles": - if e.ComplexityRoot.Query.Roles == nil { + case "PostgresGrantAccessActivityLogEntry.createdAt": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Query_roles_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.data": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data == nil { + break } - return e.ComplexityRoot.Query.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data(childComplexity), true - case "Query.search": - if e.ComplexityRoot.Query.Search == nil { + case "PostgresGrantAccessActivityLogEntry.environmentName": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_Query_search_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.id": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID == nil { + break } - return e.ComplexityRoot.Query.Search(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(search.SearchFilter)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID(childComplexity), true - case "Query.serviceAccount": - if e.ComplexityRoot.Query.ServiceAccount == nil { + case "PostgresGrantAccessActivityLogEntry.message": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message == nil { break } - args, err := ec.field_Query_serviceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.resourceName": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.Query.ServiceAccount(childComplexity, args["id"].(ident.Ident)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName(childComplexity), true - case "Query.serviceAccounts": - if e.ComplexityRoot.Query.ServiceAccounts == nil { + case "PostgresGrantAccessActivityLogEntry.resourceType": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Query_serviceAccounts_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.teamSlug": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug == nil { + break } - return e.ComplexityRoot.Query.ServiceAccounts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug(childComplexity), true - case "Query.team": - if e.ComplexityRoot.Query.Team == nil { + case "PostgresGrantAccessActivityLogEntryData.grantee": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee == nil { break } - args, err := ec.field_Query_team_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee(childComplexity), true + + case "PostgresGrantAccessActivityLogEntryData.until": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until == nil { + break } - return e.ComplexityRoot.Query.Team(childComplexity, args["slug"].(slug.Slug)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until(childComplexity), true - case "Query.teams": - if e.ComplexityRoot.Query.Teams == nil { + case "PostgresInstance.audit": + if e.ComplexityRoot.PostgresInstance.Audit == nil { break } - args, err := ec.field_Query_teams_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresInstance.Audit(childComplexity), true + + case "PostgresInstance.environment": + if e.ComplexityRoot.PostgresInstance.Environment == nil { + break } - return e.ComplexityRoot.Query.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamOrder), args["filter"].(*team.TeamFilter)), true + return e.ComplexityRoot.PostgresInstance.Environment(childComplexity), true - case "Query.teamsUtilization": - if e.ComplexityRoot.Query.TeamsUtilization == nil { + case "PostgresInstance.highAvailability": + if e.ComplexityRoot.PostgresInstance.HighAvailability == nil { break } - args, err := ec.field_Query_teamsUtilization_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresInstance.HighAvailability(childComplexity), true + + case "PostgresInstance.id": + if e.ComplexityRoot.PostgresInstance.ID == nil { + break } - return e.ComplexityRoot.Query.TeamsUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.PostgresInstance.ID(childComplexity), true - case "Query.unleashReleaseChannels": - if e.ComplexityRoot.Query.UnleashReleaseChannels == nil { + case "PostgresInstance.maintenanceWindow": + if e.ComplexityRoot.PostgresInstance.MaintenanceWindow == nil { break } - return e.ComplexityRoot.Query.UnleashReleaseChannels(childComplexity), true + return e.ComplexityRoot.PostgresInstance.MaintenanceWindow(childComplexity), true - case "Query.user": - if e.ComplexityRoot.Query.User == nil { + case "PostgresInstance.majorVersion": + if e.ComplexityRoot.PostgresInstance.MajorVersion == nil { break } - args, err := ec.field_Query_user_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresInstance.MajorVersion(childComplexity), true + + case "PostgresInstance.name": + if e.ComplexityRoot.PostgresInstance.Name == nil { + break } - return e.ComplexityRoot.Query.User(childComplexity, args["email"].(*string)), true + return e.ComplexityRoot.PostgresInstance.Name(childComplexity), true - case "Query.userSyncLog": - if e.ComplexityRoot.Query.UserSyncLog == nil { + case "PostgresInstance.resources": + if e.ComplexityRoot.PostgresInstance.Resources == nil { break } - args, err := ec.field_Query_userSyncLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.UserSyncLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresInstance.Resources(childComplexity), true - case "Query.users": - if e.ComplexityRoot.Query.Users == nil { + case "PostgresInstance.state": + if e.ComplexityRoot.PostgresInstance.State == nil { break } - args, err := ec.field_Query_users_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*user.UserOrder)), true + return e.ComplexityRoot.PostgresInstance.State(childComplexity), true - case "Query.vulnerabilityFixHistory": - if e.ComplexityRoot.Query.VulnerabilityFixHistory == nil { + case "PostgresInstance.team": + if e.ComplexityRoot.PostgresInstance.Team == nil { break } - args, err := ec.field_Query_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.PostgresInstance.Team(childComplexity), true - case "Query.vulnerabilitySummary": - if e.ComplexityRoot.Query.VulnerabilitySummary == nil { + case "PostgresInstance.teamEnvironment": + if e.ComplexityRoot.PostgresInstance.TeamEnvironment == nil { break } - return e.ComplexityRoot.Query.VulnerabilitySummary(childComplexity), true + return e.ComplexityRoot.PostgresInstance.TeamEnvironment(childComplexity), true - case "Reconciler.activityLog": - if e.ComplexityRoot.Reconciler.ActivityLog == nil { + case "PostgresInstance.workloads": + if e.ComplexityRoot.PostgresInstance.Workloads == nil { break } - args, err := ec.field_Reconciler_activityLog_args(ctx, rawArgs) + args, err := ec.field_PostgresInstance_workloads_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Reconciler.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.PostgresInstance.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Reconciler.config": - if e.ComplexityRoot.Reconciler.Config == nil { + case "PostgresInstanceAudit.enabled": + if e.ComplexityRoot.PostgresInstanceAudit.Enabled == nil { break } - return e.ComplexityRoot.Reconciler.Config(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.Enabled(childComplexity), true - case "Reconciler.configured": - if e.ComplexityRoot.Reconciler.Configured == nil { + case "PostgresInstanceAudit.statementClasses": + if e.ComplexityRoot.PostgresInstanceAudit.StatementClasses == nil { break } - return e.ComplexityRoot.Reconciler.Configured(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.StatementClasses(childComplexity), true - case "Reconciler.description": - if e.ComplexityRoot.Reconciler.Description == nil { + case "PostgresInstanceAudit.url": + if e.ComplexityRoot.PostgresInstanceAudit.URL == nil { break } - return e.ComplexityRoot.Reconciler.Description(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.URL(childComplexity), true - case "Reconciler.displayName": - if e.ComplexityRoot.Reconciler.DisplayName == nil { + case "PostgresInstanceConnection.edges": + if e.ComplexityRoot.PostgresInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.Reconciler.DisplayName(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.Edges(childComplexity), true - case "Reconciler.enabled": - if e.ComplexityRoot.Reconciler.Enabled == nil { + case "PostgresInstanceConnection.nodes": + if e.ComplexityRoot.PostgresInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.Reconciler.Enabled(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.Nodes(childComplexity), true - case "Reconciler.errors": - if e.ComplexityRoot.Reconciler.Errors == nil { + case "PostgresInstanceConnection.pageInfo": + if e.ComplexityRoot.PostgresInstanceConnection.PageInfo == nil { break } - args, err := ec.field_Reconciler_errors_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Reconciler.Errors(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresInstanceConnection.PageInfo(childComplexity), true - case "Reconciler.id": - if e.ComplexityRoot.Reconciler.ID == nil { + case "PostgresInstanceEdge.cursor": + if e.ComplexityRoot.PostgresInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.Reconciler.ID(childComplexity), true + return e.ComplexityRoot.PostgresInstanceEdge.Cursor(childComplexity), true - case "Reconciler.name": - if e.ComplexityRoot.Reconciler.Name == nil { + case "PostgresInstanceEdge.node": + if e.ComplexityRoot.PostgresInstanceEdge.Node == nil { break } - return e.ComplexityRoot.Reconciler.Name(childComplexity), true + return e.ComplexityRoot.PostgresInstanceEdge.Node(childComplexity), true - case "ReconcilerConfig.configured": - if e.ComplexityRoot.ReconcilerConfig.Configured == nil { + case "PostgresInstanceMaintenanceWindow.day": + if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Configured(childComplexity), true + return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day(childComplexity), true - case "ReconcilerConfig.description": - if e.ComplexityRoot.ReconcilerConfig.Description == nil { + case "PostgresInstanceMaintenanceWindow.hour": + if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Description(childComplexity), true + return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour(childComplexity), true - case "ReconcilerConfig.displayName": - if e.ComplexityRoot.ReconcilerConfig.DisplayName == nil { + case "PostgresInstanceResources.cpu": + if e.ComplexityRoot.PostgresInstanceResources.CPU == nil { break } - return e.ComplexityRoot.ReconcilerConfig.DisplayName(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.CPU(childComplexity), true - case "ReconcilerConfig.key": - if e.ComplexityRoot.ReconcilerConfig.Key == nil { + case "PostgresInstanceResources.diskSize": + if e.ComplexityRoot.PostgresInstanceResources.DiskSize == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Key(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.DiskSize(childComplexity), true - case "ReconcilerConfig.secret": - if e.ComplexityRoot.ReconcilerConfig.Secret == nil { + case "PostgresInstanceResources.memory": + if e.ComplexityRoot.PostgresInstanceResources.Memory == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Secret(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.Memory(childComplexity), true - case "ReconcilerConfig.value": - if e.ComplexityRoot.ReconcilerConfig.Value == nil { + case "Price.value": + if e.ComplexityRoot.Price.Value == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Value(childComplexity), true + return e.ComplexityRoot.Price.Value(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor == nil { + case "PrometheusAlarm.action": + if e.ComplexityRoot.PrometheusAlarm.Action == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Action(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt == nil { + case "PrometheusAlarm.consequence": + if e.ComplexityRoot.PrometheusAlarm.Consequence == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Consequence(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.data": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data == nil { + case "PrometheusAlarm.since": + if e.ComplexityRoot.PrometheusAlarm.Since == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Since(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName == nil { + case "PrometheusAlarm.state": + if e.ComplexityRoot.PrometheusAlarm.State == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.State(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID == nil { + case "PrometheusAlarm.summary": + if e.ComplexityRoot.PrometheusAlarm.Summary == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Summary(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message == nil { + case "PrometheusAlarm.value": + if e.ComplexityRoot.PrometheusAlarm.Value == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Value(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName == nil { + case "PrometheusAlert.alarms": + if e.ComplexityRoot.PrometheusAlert.Alarms == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Alarms(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType == nil { + case "PrometheusAlert.duration": + if e.ComplexityRoot.PrometheusAlert.Duration == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Duration(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug == nil { + case "PrometheusAlert.id": + if e.ComplexityRoot.PrometheusAlert.ID == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.ID(childComplexity), true - case "ReconcilerConfiguredActivityLogEntryData.updatedKeys": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys == nil { + case "PrometheusAlert.name": + if e.ComplexityRoot.PrometheusAlert.Name == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Name(childComplexity), true - case "ReconcilerConnection.edges": - if e.ComplexityRoot.ReconcilerConnection.Edges == nil { + case "PrometheusAlert.query": + if e.ComplexityRoot.PrometheusAlert.Query == nil { break } - return e.ComplexityRoot.ReconcilerConnection.Edges(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Query(childComplexity), true - case "ReconcilerConnection.nodes": - if e.ComplexityRoot.ReconcilerConnection.Nodes == nil { + case "PrometheusAlert.ruleGroup": + if e.ComplexityRoot.PrometheusAlert.RuleGroup == nil { break } - return e.ComplexityRoot.ReconcilerConnection.Nodes(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.RuleGroup(childComplexity), true - case "ReconcilerConnection.pageInfo": - if e.ComplexityRoot.ReconcilerConnection.PageInfo == nil { + case "PrometheusAlert.state": + if e.ComplexityRoot.PrometheusAlert.State == nil { break } - return e.ComplexityRoot.ReconcilerConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.State(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor == nil { + case "PrometheusAlert.team": + if e.ComplexityRoot.PrometheusAlert.Team == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Team(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt == nil { + case "PrometheusAlert.teamEnvironment": + if e.ComplexityRoot.PrometheusAlert.TeamEnvironment == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.TeamEnvironment(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName == nil { + case "Query.cve": + if e.ComplexityRoot.Query.CVE == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName(childComplexity), true - - case "ReconcilerDisabledActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID == nil { - break + args, err := ec.field_Query_cve_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Query.CVE(childComplexity, args["identifier"].(string)), true - case "ReconcilerDisabledActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message == nil { + case "Query.costMonthlySummary": + if e.ComplexityRoot.Query.CostMonthlySummary == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message(childComplexity), true + args, err := ec.field_Query_costMonthlySummary_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ReconcilerDisabledActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName == nil { + return e.ComplexityRoot.Query.CostMonthlySummary(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + + case "Query.currentUnitPrices": + if e.ComplexityRoot.Query.CurrentUnitPrices == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Query.CurrentUnitPrices(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType == nil { + case "Query.cves": + if e.ComplexityRoot.Query.Cves == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType(childComplexity), true - - case "ReconcilerDisabledActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_Query_cves_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Query.Cves(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.CVEOrder)), true - case "ReconcilerEdge.cursor": - if e.ComplexityRoot.ReconcilerEdge.Cursor == nil { + case "Query.deployments": + if e.ComplexityRoot.Query.Deployments == nil { break } - return e.ComplexityRoot.ReconcilerEdge.Cursor(childComplexity), true - - case "ReconcilerEdge.node": - if e.ComplexityRoot.ReconcilerEdge.Node == nil { - break + args, err := ec.field_Query_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEdge.Node(childComplexity), true + return e.ComplexityRoot.Query.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*deployment.DeploymentOrder), args["filter"].(*deployment.DeploymentFilter)), true - case "ReconcilerEnabledActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor == nil { + case "Query.environment": + if e.ComplexityRoot.Query.Environment == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor(childComplexity), true - - case "ReconcilerEnabledActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Query_environment_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Query.Environment(childComplexity, args["name"].(string)), true - case "ReconcilerEnabledActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName == nil { + case "Query.environments": + if e.ComplexityRoot.Query.Environments == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName(childComplexity), true - - case "ReconcilerEnabledActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID == nil { - break + args, err := ec.field_Query_environments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Query.Environments(childComplexity, args["orderBy"].(*environment.EnvironmentOrder)), true - case "ReconcilerEnabledActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message == nil { + case "Query.features": + if e.ComplexityRoot.Query.Features == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Query.Features(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName == nil { + case "Query.imageVulnerabilityHistory": + if e.ComplexityRoot.Query.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName(childComplexity), true - - case "ReconcilerEnabledActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Query_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Query.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true - case "ReconcilerEnabledActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug == nil { + case "Query.me": + if e.ComplexityRoot.Query.Me == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Query.Me(childComplexity), true - case "ReconcilerError.correlationID": - if e.ComplexityRoot.ReconcilerError.CorrelationID == nil { + case "Query.node": + if e.ComplexityRoot.Query.Node == nil { break } - return e.ComplexityRoot.ReconcilerError.CorrelationID(childComplexity), true - - case "ReconcilerError.createdAt": - if e.ComplexityRoot.ReconcilerError.CreatedAt == nil { - break + args, err := ec.field_Query_node_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerError.CreatedAt(childComplexity), true + return e.ComplexityRoot.Query.Node(childComplexity, args["id"].(ident.Ident)), true - case "ReconcilerError.id": - if e.ComplexityRoot.ReconcilerError.ID == nil { + case "Query.reconcilers": + if e.ComplexityRoot.Query.Reconcilers == nil { break } - return e.ComplexityRoot.ReconcilerError.ID(childComplexity), true - - case "ReconcilerError.message": - if e.ComplexityRoot.ReconcilerError.Message == nil { - break + args, err := ec.field_Query_reconcilers_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerError.Message(childComplexity), true + return e.ComplexityRoot.Query.Reconcilers(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ReconcilerError.team": - if e.ComplexityRoot.ReconcilerError.Team == nil { + case "Query.roles": + if e.ComplexityRoot.Query.Roles == nil { break } - return e.ComplexityRoot.ReconcilerError.Team(childComplexity), true - - case "ReconcilerErrorConnection.edges": - if e.ComplexityRoot.ReconcilerErrorConnection.Edges == nil { - break + args, err := ec.field_Query_roles_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerErrorConnection.Edges(childComplexity), true + return e.ComplexityRoot.Query.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ReconcilerErrorConnection.nodes": - if e.ComplexityRoot.ReconcilerErrorConnection.Nodes == nil { + case "Query.search": + if e.ComplexityRoot.Query.Search == nil { break } - return e.ComplexityRoot.ReconcilerErrorConnection.Nodes(childComplexity), true - - case "ReconcilerErrorConnection.pageInfo": - if e.ComplexityRoot.ReconcilerErrorConnection.PageInfo == nil { - break + args, err := ec.field_Query_search_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerErrorConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Query.Search(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(search.SearchFilter)), true - case "ReconcilerErrorEdge.cursor": - if e.ComplexityRoot.ReconcilerErrorEdge.Cursor == nil { + case "Query.serviceAccount": + if e.ComplexityRoot.Query.ServiceAccount == nil { break } - return e.ComplexityRoot.ReconcilerErrorEdge.Cursor(childComplexity), true - - case "ReconcilerErrorEdge.node": - if e.ComplexityRoot.ReconcilerErrorEdge.Node == nil { - break + args, err := ec.field_Query_serviceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerErrorEdge.Node(childComplexity), true + return e.ComplexityRoot.Query.ServiceAccount(childComplexity, args["id"].(ident.Ident)), true - case "RemoveRepositoryFromTeamPayload.success": - if e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success == nil { + case "Query.serviceAccounts": + if e.ComplexityRoot.Query.ServiceAccounts == nil { break } - return e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success(childComplexity), true - - case "RemoveSecretValuePayload.secret": - if e.ComplexityRoot.RemoveSecretValuePayload.Secret == nil { - break + args, err := ec.field_Query_serviceAccounts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RemoveSecretValuePayload.Secret(childComplexity), true + return e.ComplexityRoot.Query.ServiceAccounts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RemoveTeamMemberPayload.team": - if e.ComplexityRoot.RemoveTeamMemberPayload.Team == nil { + case "Query.team": + if e.ComplexityRoot.Query.Team == nil { break } - return e.ComplexityRoot.RemoveTeamMemberPayload.Team(childComplexity), true - - case "RemoveTeamMemberPayload.user": - if e.ComplexityRoot.RemoveTeamMemberPayload.User == nil { - break + args, err := ec.field_Query_team_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RemoveTeamMemberPayload.User(childComplexity), true + return e.ComplexityRoot.Query.Team(childComplexity, args["slug"].(slug.Slug)), true - case "Repository.id": - if e.ComplexityRoot.Repository.ID == nil { + case "Query.teams": + if e.ComplexityRoot.Query.Teams == nil { break } - return e.ComplexityRoot.Repository.ID(childComplexity), true - - case "Repository.name": - if e.ComplexityRoot.Repository.Name == nil { - break + args, err := ec.field_Query_teams_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Repository.Name(childComplexity), true + return e.ComplexityRoot.Query.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamOrder), args["filter"].(*team.TeamFilter)), true - case "Repository.team": - if e.ComplexityRoot.Repository.Team == nil { + case "Query.teamsUtilization": + if e.ComplexityRoot.Query.TeamsUtilization == nil { break } - return e.ComplexityRoot.Repository.Team(childComplexity), true - - case "RepositoryAddedActivityLogEntry.actor": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Query_teamsUtilization_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Query.TeamsUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true - case "RepositoryAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt == nil { + case "Query.unleashReleaseChannels": + if e.ComplexityRoot.Query.UnleashReleaseChannels == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Query.UnleashReleaseChannels(childComplexity), true - case "RepositoryAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName == nil { + case "Query.user": + if e.ComplexityRoot.Query.User == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName(childComplexity), true - - case "RepositoryAddedActivityLogEntry.id": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID == nil { - break + args, err := ec.field_Query_user_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Query.User(childComplexity, args["email"].(*string)), true - case "RepositoryAddedActivityLogEntry.message": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message == nil { + case "Query.userSyncLog": + if e.ComplexityRoot.Query.UserSyncLog == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message(childComplexity), true - - case "RepositoryAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_Query_userSyncLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Query.UserSyncLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RepositoryAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType == nil { + case "Query.users": + if e.ComplexityRoot.Query.Users == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType(childComplexity), true - - case "RepositoryAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_Query_users_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Query.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*user.UserOrder)), true - case "RepositoryConnection.edges": - if e.ComplexityRoot.RepositoryConnection.Edges == nil { + case "Query.vulnerabilityFixHistory": + if e.ComplexityRoot.Query.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.RepositoryConnection.Edges(childComplexity), true - - case "RepositoryConnection.nodes": - if e.ComplexityRoot.RepositoryConnection.Nodes == nil { - break + args, err := ec.field_Query_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Query.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "RepositoryConnection.pageInfo": - if e.ComplexityRoot.RepositoryConnection.PageInfo == nil { + case "Query.vulnerabilitySummary": + if e.ComplexityRoot.Query.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.RepositoryConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Query.VulnerabilitySummary(childComplexity), true - case "RepositoryEdge.cursor": - if e.ComplexityRoot.RepositoryEdge.Cursor == nil { + case "Reconciler.activityLog": + if e.ComplexityRoot.Reconciler.ActivityLog == nil { break } - return e.ComplexityRoot.RepositoryEdge.Cursor(childComplexity), true - - case "RepositoryEdge.node": - if e.ComplexityRoot.RepositoryEdge.Node == nil { - break + args, err := ec.field_Reconciler_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryEdge.Node(childComplexity), true + return e.ComplexityRoot.Reconciler.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "RepositoryRemovedActivityLogEntry.actor": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor == nil { + case "Reconciler.config": + if e.ComplexityRoot.Reconciler.Config == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Reconciler.Config(childComplexity), true - case "RepositoryRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt == nil { + case "Reconciler.configured": + if e.ComplexityRoot.Reconciler.Configured == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Reconciler.Configured(childComplexity), true - case "RepositoryRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName == nil { + case "Reconciler.description": + if e.ComplexityRoot.Reconciler.Description == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Reconciler.Description(childComplexity), true - case "RepositoryRemovedActivityLogEntry.id": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID == nil { + case "Reconciler.displayName": + if e.ComplexityRoot.Reconciler.DisplayName == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Reconciler.DisplayName(childComplexity), true - case "RepositoryRemovedActivityLogEntry.message": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message == nil { + case "Reconciler.enabled": + if e.ComplexityRoot.Reconciler.Enabled == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Reconciler.Enabled(childComplexity), true - case "RepositoryRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName == nil { + case "Reconciler.errors": + if e.ComplexityRoot.Reconciler.Errors == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName(childComplexity), true + args, err := ec.field_Reconciler_errors_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "RepositoryRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType == nil { + return e.ComplexityRoot.Reconciler.Errors(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Reconciler.id": + if e.ComplexityRoot.Reconciler.ID == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Reconciler.ID(childComplexity), true - case "RepositoryRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug == nil { + case "Reconciler.name": + if e.ComplexityRoot.Reconciler.Name == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Reconciler.Name(childComplexity), true - case "RequestTeamDeletionPayload.key": - if e.ComplexityRoot.RequestTeamDeletionPayload.Key == nil { + case "ReconcilerConfig.configured": + if e.ComplexityRoot.ReconcilerConfig.Configured == nil { break } - return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Configured(childComplexity), true - case "RestartApplicationPayload.application": - if e.ComplexityRoot.RestartApplicationPayload.Application == nil { + case "ReconcilerConfig.description": + if e.ComplexityRoot.ReconcilerConfig.Description == nil { break } - return e.ComplexityRoot.RestartApplicationPayload.Application(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Description(childComplexity), true - case "RevokeRoleFromServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount == nil { + case "ReconcilerConfig.displayName": + if e.ComplexityRoot.ReconcilerConfig.DisplayName == nil { break } - return e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.DisplayName(childComplexity), true - case "RevokeTeamAccessToUnleashPayload.unleash": - if e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash == nil { + case "ReconcilerConfig.key": + if e.ComplexityRoot.ReconcilerConfig.Key == nil { break } - return e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Key(childComplexity), true - case "Role.description": - if e.ComplexityRoot.Role.Description == nil { + case "ReconcilerConfig.secret": + if e.ComplexityRoot.ReconcilerConfig.Secret == nil { break } - return e.ComplexityRoot.Role.Description(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Secret(childComplexity), true - case "Role.id": - if e.ComplexityRoot.Role.ID == nil { + case "ReconcilerConfig.value": + if e.ComplexityRoot.ReconcilerConfig.Value == nil { break } - return e.ComplexityRoot.Role.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Value(childComplexity), true - case "Role.name": - if e.ComplexityRoot.Role.Name == nil { + case "ReconcilerConfiguredActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.Role.Name(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.actor": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor == nil { + case "ReconcilerConfiguredActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.createdAt": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt == nil { + case "ReconcilerConfiguredActivityLogEntry.data": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.data": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data == nil { + case "ReconcilerConfiguredActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.environmentName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName == nil { + case "ReconcilerConfiguredActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.id": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID == nil { + case "ReconcilerConfiguredActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.message": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message == nil { + case "ReconcilerConfiguredActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.resourceName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName == nil { + case "ReconcilerConfiguredActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.resourceType": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType == nil { + case "ReconcilerConfiguredActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.teamSlug": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug == nil { + case "ReconcilerConfiguredActivityLogEntryData.updatedKeys": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntryData.roleName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName == nil { + case "ReconcilerConnection.edges": + if e.ComplexityRoot.ReconcilerConnection.Edges == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.Edges(childComplexity), true - case "RoleAssignedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt == nil { + case "ReconcilerConnection.nodes": + if e.ComplexityRoot.ReconcilerConnection.Nodes == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.Nodes(childComplexity), true - case "RoleAssignedUserSyncLogEntry.id": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID == nil { + case "ReconcilerConnection.pageInfo": + if e.ComplexityRoot.ReconcilerConnection.PageInfo == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.PageInfo(childComplexity), true - case "RoleAssignedUserSyncLogEntry.message": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message == nil { + case "ReconcilerDisabledActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor(childComplexity), true - case "RoleAssignedUserSyncLogEntry.roleName": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName == nil { + case "ReconcilerDisabledActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail == nil { + case "ReconcilerDisabledActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userID": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID == nil { + case "ReconcilerDisabledActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userName": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName == nil { + case "ReconcilerDisabledActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message(childComplexity), true - case "RoleConnection.edges": - if e.ComplexityRoot.RoleConnection.Edges == nil { + case "ReconcilerDisabledActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleConnection.Edges(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName(childComplexity), true - case "RoleConnection.nodes": - if e.ComplexityRoot.RoleConnection.Nodes == nil { + case "ReconcilerDisabledActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType(childComplexity), true - case "RoleConnection.pageInfo": - if e.ComplexityRoot.RoleConnection.PageInfo == nil { + case "ReconcilerDisabledActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug(childComplexity), true - case "RoleEdge.cursor": - if e.ComplexityRoot.RoleEdge.Cursor == nil { + case "ReconcilerEdge.cursor": + if e.ComplexityRoot.ReconcilerEdge.Cursor == nil { break } - return e.ComplexityRoot.RoleEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ReconcilerEdge.Cursor(childComplexity), true - case "RoleEdge.node": - if e.ComplexityRoot.RoleEdge.Node == nil { + case "ReconcilerEdge.node": + if e.ComplexityRoot.ReconcilerEdge.Node == nil { break } - return e.ComplexityRoot.RoleEdge.Node(childComplexity), true + return e.ComplexityRoot.ReconcilerEdge.Node(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.actor": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor == nil { + case "ReconcilerEnabledActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.createdAt": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt == nil { + case "ReconcilerEnabledActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.data": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data == nil { + case "ReconcilerEnabledActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.environmentName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName == nil { + case "ReconcilerEnabledActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.id": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID == nil { + case "ReconcilerEnabledActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.message": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message == nil { + case "ReconcilerEnabledActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.resourceName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName == nil { + case "ReconcilerEnabledActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.resourceType": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType == nil { + case "ReconcilerEnabledActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.teamSlug": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug == nil { + case "ReconcilerError.correlationID": + if e.ComplexityRoot.ReconcilerError.CorrelationID == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ReconcilerError.CorrelationID(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntryData.roleName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName == nil { + case "ReconcilerError.createdAt": + if e.ComplexityRoot.ReconcilerError.CreatedAt == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerError.CreatedAt(childComplexity), true - case "RoleRevokedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt == nil { + case "ReconcilerError.id": + if e.ComplexityRoot.ReconcilerError.ID == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerError.ID(childComplexity), true - case "RoleRevokedUserSyncLogEntry.id": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID == nil { + case "ReconcilerError.message": + if e.ComplexityRoot.ReconcilerError.Message == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerError.Message(childComplexity), true - case "RoleRevokedUserSyncLogEntry.message": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message == nil { + case "ReconcilerError.team": + if e.ComplexityRoot.ReconcilerError.Team == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerError.Team(childComplexity), true - case "RoleRevokedUserSyncLogEntry.roleName": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName == nil { + case "ReconcilerErrorConnection.edges": + if e.ComplexityRoot.ReconcilerErrorConnection.Edges == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorConnection.Edges(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail == nil { + case "ReconcilerErrorConnection.nodes": + if e.ComplexityRoot.ReconcilerErrorConnection.Nodes == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorConnection.Nodes(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userID": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID == nil { + case "ReconcilerErrorConnection.pageInfo": + if e.ComplexityRoot.ReconcilerErrorConnection.PageInfo == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorConnection.PageInfo(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userName": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName == nil { + case "ReconcilerErrorEdge.cursor": + if e.ComplexityRoot.ReconcilerErrorEdge.Cursor == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorEdge.Cursor(childComplexity), true - case "SearchNodeConnection.edges": - if e.ComplexityRoot.SearchNodeConnection.Edges == nil { + case "ReconcilerErrorEdge.node": + if e.ComplexityRoot.ReconcilerErrorEdge.Node == nil { break } - return e.ComplexityRoot.SearchNodeConnection.Edges(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorEdge.Node(childComplexity), true - case "SearchNodeConnection.nodes": - if e.ComplexityRoot.SearchNodeConnection.Nodes == nil { + case "RemoveConfigValuePayload.config": + if e.ComplexityRoot.RemoveConfigValuePayload.Config == nil { break } - return e.ComplexityRoot.SearchNodeConnection.Nodes(childComplexity), true + return e.ComplexityRoot.RemoveConfigValuePayload.Config(childComplexity), true - case "SearchNodeConnection.pageInfo": - if e.ComplexityRoot.SearchNodeConnection.PageInfo == nil { + case "RemoveRepositoryFromTeamPayload.success": + if e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success == nil { break } - return e.ComplexityRoot.SearchNodeConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success(childComplexity), true - case "SearchNodeEdge.cursor": - if e.ComplexityRoot.SearchNodeEdge.Cursor == nil { + case "RemoveSecretValuePayload.secret": + if e.ComplexityRoot.RemoveSecretValuePayload.Secret == nil { break } - return e.ComplexityRoot.SearchNodeEdge.Cursor(childComplexity), true + return e.ComplexityRoot.RemoveSecretValuePayload.Secret(childComplexity), true - case "SearchNodeEdge.node": - if e.ComplexityRoot.SearchNodeEdge.Node == nil { + case "RemoveTeamMemberPayload.team": + if e.ComplexityRoot.RemoveTeamMemberPayload.Team == nil { break } - return e.ComplexityRoot.SearchNodeEdge.Node(childComplexity), true + return e.ComplexityRoot.RemoveTeamMemberPayload.Team(childComplexity), true - case "Secret.activityLog": - if e.ComplexityRoot.Secret.ActivityLog == nil { + case "RemoveTeamMemberPayload.user": + if e.ComplexityRoot.RemoveTeamMemberPayload.User == nil { break } - args, err := ec.field_Secret_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.RemoveTeamMemberPayload.User(childComplexity), true - case "Secret.applications": - if e.ComplexityRoot.Secret.Applications == nil { + case "Repository.id": + if e.ComplexityRoot.Repository.ID == nil { break } - args, err := ec.field_Secret_applications_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Repository.ID(childComplexity), true - case "Secret.environment": - if e.ComplexityRoot.Secret.Environment == nil { + case "Repository.name": + if e.ComplexityRoot.Repository.Name == nil { break } - return e.ComplexityRoot.Secret.Environment(childComplexity), true + return e.ComplexityRoot.Repository.Name(childComplexity), true - case "Secret.id": - if e.ComplexityRoot.Secret.ID == nil { + case "Repository.team": + if e.ComplexityRoot.Repository.Team == nil { break } - return e.ComplexityRoot.Secret.ID(childComplexity), true + return e.ComplexityRoot.Repository.Team(childComplexity), true - case "Secret.jobs": - if e.ComplexityRoot.Secret.Jobs == nil { + case "RepositoryAddedActivityLogEntry.actor": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor == nil { break } - args, err := ec.field_Secret_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor(childComplexity), true - case "Secret.keys": - if e.ComplexityRoot.Secret.Keys == nil { + case "RepositoryAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Secret.Keys(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt(childComplexity), true - case "Secret.lastModifiedAt": - if e.ComplexityRoot.Secret.LastModifiedAt == nil { + case "RepositoryAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Secret.LastModifiedAt(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "Secret.lastModifiedBy": - if e.ComplexityRoot.Secret.LastModifiedBy == nil { + case "RepositoryAddedActivityLogEntry.id": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Secret.LastModifiedBy(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID(childComplexity), true - case "Secret.name": - if e.ComplexityRoot.Secret.Name == nil { + case "RepositoryAddedActivityLogEntry.message": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Secret.Name(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message(childComplexity), true - case "Secret.team": - if e.ComplexityRoot.Secret.Team == nil { + case "RepositoryAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Secret.Team(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName(childComplexity), true - case "Secret.teamEnvironment": - if e.ComplexityRoot.Secret.TeamEnvironment == nil { + case "RepositoryAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Secret.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType(childComplexity), true - case "Secret.workloads": - if e.ComplexityRoot.Secret.Workloads == nil { + case "RepositoryAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Secret_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretConnection.edges": - if e.ComplexityRoot.SecretConnection.Edges == nil { + case "RepositoryConnection.edges": + if e.ComplexityRoot.RepositoryConnection.Edges == nil { break } - return e.ComplexityRoot.SecretConnection.Edges(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.Edges(childComplexity), true - case "SecretConnection.nodes": - if e.ComplexityRoot.SecretConnection.Nodes == nil { + case "RepositoryConnection.nodes": + if e.ComplexityRoot.RepositoryConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretConnection.Nodes(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.Nodes(childComplexity), true - case "SecretConnection.pageInfo": - if e.ComplexityRoot.SecretConnection.PageInfo == nil { + case "RepositoryConnection.pageInfo": + if e.ComplexityRoot.RepositoryConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.PageInfo(childComplexity), true - case "SecretCreatedActivityLogEntry.actor": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor == nil { + case "RepositoryEdge.cursor": + if e.ComplexityRoot.RepositoryEdge.Cursor == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RepositoryEdge.Cursor(childComplexity), true - case "SecretCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt == nil { + case "RepositoryEdge.node": + if e.ComplexityRoot.RepositoryEdge.Node == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RepositoryEdge.Node(childComplexity), true - case "SecretCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName == nil { + case "RepositoryRemovedActivityLogEntry.actor": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor(childComplexity), true - case "SecretCreatedActivityLogEntry.id": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ID == nil { + case "RepositoryRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "SecretCreatedActivityLogEntry.message": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.Message == nil { + case "RepositoryRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName == nil { + case "RepositoryRemovedActivityLogEntry.id": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID(childComplexity), true - case "SecretCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType == nil { + case "RepositoryRemovedActivityLogEntry.message": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message(childComplexity), true - case "SecretCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug == nil { + case "RepositoryRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName(childComplexity), true - case "SecretDeletedActivityLogEntry.actor": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor == nil { + case "RepositoryRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType(childComplexity), true - case "SecretDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt == nil { + case "RepositoryRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName == nil { + case "RequestTeamDeletionPayload.key": + if e.ComplexityRoot.RequestTeamDeletionPayload.Key == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true - case "SecretDeletedActivityLogEntry.id": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ID == nil { + case "RestartApplicationPayload.application": + if e.ComplexityRoot.RestartApplicationPayload.Application == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RestartApplicationPayload.Application(childComplexity), true - case "SecretDeletedActivityLogEntry.message": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.Message == nil { + case "RevokeRoleFromServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount(childComplexity), true - case "SecretDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName == nil { + case "RevokeTeamAccessToUnleashPayload.unleash": + if e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash(childComplexity), true - case "SecretDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType == nil { + case "Role.description": + if e.ComplexityRoot.Role.Description == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Role.Description(childComplexity), true - case "SecretDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug == nil { + case "Role.id": + if e.ComplexityRoot.Role.ID == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Role.ID(childComplexity), true - case "SecretEdge.cursor": - if e.ComplexityRoot.SecretEdge.Cursor == nil { + case "Role.name": + if e.ComplexityRoot.Role.Name == nil { break } - return e.ComplexityRoot.SecretEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Role.Name(childComplexity), true - case "SecretEdge.node": - if e.ComplexityRoot.SecretEdge.Node == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.actor": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretEdge.Node(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor(childComplexity), true - case "SecretValue.name": - if e.ComplexityRoot.SecretValue.Name == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.createdAt": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValue.Name(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValue.value": - if e.ComplexityRoot.SecretValue.Value == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.data": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SecretValue.Value(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data(childComplexity), true - case "SecretValueAddedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.environmentName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValueAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.id": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID(childComplexity), true - case "SecretValueAddedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.message": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message(childComplexity), true - case "SecretValueAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.resourceName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName(childComplexity), true - case "SecretValueAddedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.resourceType": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType(childComplexity), true - case "SecretValueAddedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.teamSlug": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug(childComplexity), true - case "SecretValueAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName == nil { + case "RoleAssignedToServiceAccountActivityLogEntryData.roleName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName(childComplexity), true - case "SecretValueAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType == nil { + case "RoleAssignedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt(childComplexity), true - case "SecretValueAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug == nil { + case "RoleAssignedUserSyncLogEntry.id": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID(childComplexity), true - case "SecretValueAddedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName == nil { + case "RoleAssignedUserSyncLogEntry.message": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message(childComplexity), true - case "SecretValueRemovedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor == nil { + case "RoleAssignedUserSyncLogEntry.roleName": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName(childComplexity), true - case "SecretValueRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt == nil { + case "RoleAssignedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail(childComplexity), true - case "SecretValueRemovedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data == nil { + case "RoleAssignedUserSyncLogEntry.userID": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID(childComplexity), true - case "SecretValueRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName == nil { + case "RoleAssignedUserSyncLogEntry.userName": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName(childComplexity), true - case "SecretValueRemovedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID == nil { + case "RoleConnection.edges": + if e.ComplexityRoot.RoleConnection.Edges == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleConnection.Edges(childComplexity), true - case "SecretValueRemovedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message == nil { + case "RoleConnection.nodes": + if e.ComplexityRoot.RoleConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleConnection.Nodes(childComplexity), true - case "SecretValueRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName == nil { + case "RoleConnection.pageInfo": + if e.ComplexityRoot.RoleConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleConnection.PageInfo(childComplexity), true - case "SecretValueRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType == nil { + case "RoleEdge.cursor": + if e.ComplexityRoot.RoleEdge.Cursor == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleEdge.Cursor(childComplexity), true - case "SecretValueRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug == nil { + case "RoleEdge.node": + if e.ComplexityRoot.RoleEdge.Node == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleEdge.Node(childComplexity), true - case "SecretValueRemovedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.actor": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.createdAt": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.data": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.environmentName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.id": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.message": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message == nil { - break + case "RoleRevokedFromServiceAccountActivityLogEntry.resourceName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.resourceType": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.teamSlug": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug == nil { + case "RoleRevokedFromServiceAccountActivityLogEntryData.roleName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName(childComplexity), true - case "SecretValueUpdatedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName == nil { + case "RoleRevokedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt(childComplexity), true - case "SecretValuesViewedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor == nil { + case "RoleRevokedUserSyncLogEntry.id": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID(childComplexity), true - case "SecretValuesViewedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt == nil { + case "RoleRevokedUserSyncLogEntry.message": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message(childComplexity), true - case "SecretValuesViewedActivityLogEntry.data": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data == nil { + case "RoleRevokedUserSyncLogEntry.roleName": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName == nil { + case "RoleRevokedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail(childComplexity), true - case "SecretValuesViewedActivityLogEntry.id": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID == nil { + case "RoleRevokedUserSyncLogEntry.userID": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID(childComplexity), true - case "SecretValuesViewedActivityLogEntry.message": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message == nil { + case "RoleRevokedUserSyncLogEntry.userName": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName == nil { + case "SearchNodeConnection.edges": + if e.ComplexityRoot.SearchNodeConnection.Edges == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.Edges(childComplexity), true - case "SecretValuesViewedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType == nil { + case "SearchNodeConnection.nodes": + if e.ComplexityRoot.SearchNodeConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.Nodes(childComplexity), true - case "SecretValuesViewedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug == nil { + case "SearchNodeConnection.pageInfo": + if e.ComplexityRoot.SearchNodeConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.PageInfo(childComplexity), true - case "SecretValuesViewedActivityLogEntryData.reason": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason == nil { + case "SearchNodeEdge.cursor": + if e.ComplexityRoot.SearchNodeEdge.Cursor == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason(childComplexity), true + return e.ComplexityRoot.SearchNodeEdge.Cursor(childComplexity), true - case "ServiceAccount.createdAt": - if e.ComplexityRoot.ServiceAccount.CreatedAt == nil { + case "SearchNodeEdge.node": + if e.ComplexityRoot.SearchNodeEdge.Node == nil { break } - return e.ComplexityRoot.ServiceAccount.CreatedAt(childComplexity), true + return e.ComplexityRoot.SearchNodeEdge.Node(childComplexity), true - case "ServiceAccount.description": - if e.ComplexityRoot.ServiceAccount.Description == nil { + case "Secret.activityLog": + if e.ComplexityRoot.Secret.ActivityLog == nil { break } - return e.ComplexityRoot.ServiceAccount.Description(childComplexity), true - - case "ServiceAccount.id": - if e.ComplexityRoot.ServiceAccount.ID == nil { - break + args, err := ec.field_Secret_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccount.ID(childComplexity), true + return e.ComplexityRoot.Secret.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "ServiceAccount.lastUsedAt": - if e.ComplexityRoot.ServiceAccount.LastUsedAt == nil { + case "Secret.applications": + if e.ComplexityRoot.Secret.Applications == nil { break } - return e.ComplexityRoot.ServiceAccount.LastUsedAt(childComplexity), true - - case "ServiceAccount.name": - if e.ComplexityRoot.ServiceAccount.Name == nil { - break + args, err := ec.field_Secret_applications_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccount.Name(childComplexity), true + return e.ComplexityRoot.Secret.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccount.roles": - if e.ComplexityRoot.ServiceAccount.Roles == nil { + case "Secret.environment": + if e.ComplexityRoot.Secret.Environment == nil { break } - args, err := ec.field_ServiceAccount_roles_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.ServiceAccount.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Secret.Environment(childComplexity), true - case "ServiceAccount.team": - if e.ComplexityRoot.ServiceAccount.Team == nil { + case "Secret.id": + if e.ComplexityRoot.Secret.ID == nil { break } - return e.ComplexityRoot.ServiceAccount.Team(childComplexity), true + return e.ComplexityRoot.Secret.ID(childComplexity), true - case "ServiceAccount.tokens": - if e.ComplexityRoot.ServiceAccount.Tokens == nil { + case "Secret.jobs": + if e.ComplexityRoot.Secret.Jobs == nil { break } - args, err := ec.field_ServiceAccount_tokens_args(ctx, rawArgs) + args, err := ec.field_Secret_jobs_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ServiceAccount.Tokens(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Secret.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccount.updatedAt": - if e.ComplexityRoot.ServiceAccount.UpdatedAt == nil { + case "Secret.keys": + if e.ComplexityRoot.Secret.Keys == nil { break } - return e.ComplexityRoot.ServiceAccount.UpdatedAt(childComplexity), true + return e.ComplexityRoot.Secret.Keys(childComplexity), true - case "ServiceAccountConnection.edges": - if e.ComplexityRoot.ServiceAccountConnection.Edges == nil { + case "Secret.lastModifiedAt": + if e.ComplexityRoot.Secret.LastModifiedAt == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.Edges(childComplexity), true + return e.ComplexityRoot.Secret.LastModifiedAt(childComplexity), true - case "ServiceAccountConnection.nodes": - if e.ComplexityRoot.ServiceAccountConnection.Nodes == nil { + case "Secret.lastModifiedBy": + if e.ComplexityRoot.Secret.LastModifiedBy == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Secret.LastModifiedBy(childComplexity), true - case "ServiceAccountConnection.pageInfo": - if e.ComplexityRoot.ServiceAccountConnection.PageInfo == nil { + case "Secret.name": + if e.ComplexityRoot.Secret.Name == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Secret.Name(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor == nil { + case "Secret.team": + if e.ComplexityRoot.Secret.Team == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Secret.Team(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt == nil { + case "Secret.teamEnvironment": + if e.ComplexityRoot.Secret.TeamEnvironment == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Secret.TeamEnvironment(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName == nil { + case "Secret.workloads": + if e.ComplexityRoot.Secret.Workloads == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName(childComplexity), true - - case "ServiceAccountCreatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID == nil { - break + args, err := ec.field_Secret_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Secret.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccountCreatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message == nil { + case "SecretConnection.edges": + if e.ComplexityRoot.SecretConnection.Edges == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretConnection.Edges(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName == nil { + case "SecretConnection.nodes": + if e.ComplexityRoot.SecretConnection.Nodes == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretConnection.Nodes(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType == nil { + case "SecretConnection.pageInfo": + if e.ComplexityRoot.SecretConnection.PageInfo == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretConnection.PageInfo(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug == nil { + case "SecretCreatedActivityLogEntry.actor": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor == nil { + case "SecretCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt == nil { + case "SecretCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName == nil { + case "SecretCreatedActivityLogEntry.id": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID == nil { + case "SecretCreatedActivityLogEntry.message": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message == nil { + case "SecretCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName == nil { + case "SecretCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType == nil { + case "SecretCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug == nil { + case "SecretDeletedActivityLogEntry.actor": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountEdge.cursor": - if e.ComplexityRoot.ServiceAccountEdge.Cursor == nil { + case "SecretDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountEdge.node": - if e.ComplexityRoot.ServiceAccountEdge.Node == nil { + case "SecretDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountEdge.Node(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountToken.createdAt": - if e.ComplexityRoot.ServiceAccountToken.CreatedAt == nil { + case "SecretDeletedActivityLogEntry.id": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountToken.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountToken.description": - if e.ComplexityRoot.ServiceAccountToken.Description == nil { + case "SecretDeletedActivityLogEntry.message": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountToken.Description(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountToken.expiresAt": - if e.ComplexityRoot.ServiceAccountToken.ExpiresAt == nil { + case "SecretDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountToken.ExpiresAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountToken.id": - if e.ComplexityRoot.ServiceAccountToken.ID == nil { + case "SecretDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountToken.ID(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountToken.lastUsedAt": - if e.ComplexityRoot.ServiceAccountToken.LastUsedAt == nil { + case "SecretDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountToken.LastUsedAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountToken.name": - if e.ComplexityRoot.ServiceAccountToken.Name == nil { + case "SecretEdge.cursor": + if e.ComplexityRoot.SecretEdge.Cursor == nil { break } - return e.ComplexityRoot.ServiceAccountToken.Name(childComplexity), true + return e.ComplexityRoot.SecretEdge.Cursor(childComplexity), true - case "ServiceAccountToken.updatedAt": - if e.ComplexityRoot.ServiceAccountToken.UpdatedAt == nil { + case "SecretEdge.node": + if e.ComplexityRoot.SecretEdge.Node == nil { break } - return e.ComplexityRoot.ServiceAccountToken.UpdatedAt(childComplexity), true + return e.ComplexityRoot.SecretEdge.Node(childComplexity), true - case "ServiceAccountTokenConnection.edges": - if e.ComplexityRoot.ServiceAccountTokenConnection.Edges == nil { + case "SecretValue.name": + if e.ComplexityRoot.SecretValue.Name == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.Edges(childComplexity), true + return e.ComplexityRoot.SecretValue.Name(childComplexity), true - case "ServiceAccountTokenConnection.nodes": - if e.ComplexityRoot.ServiceAccountTokenConnection.Nodes == nil { + case "SecretValue.value": + if e.ComplexityRoot.SecretValue.Value == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SecretValue.Value(childComplexity), true - case "ServiceAccountTokenConnection.pageInfo": - if e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo == nil { + case "SecretValueAddedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor == nil { + case "SecretValueAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt == nil { + case "SecretValueAddedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data == nil { + case "SecretValueAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName == nil { + case "SecretValueAddedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID == nil { + case "SecretValueAddedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message == nil { + case "SecretValueAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName == nil { + case "SecretValueAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType == nil { + case "SecretValueAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug == nil { + case "SecretValueAddedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntryData.tokenName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName == nil { + case "SecretValueRemovedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor == nil { + case "SecretValueRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt == nil { + case "SecretValueRemovedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data == nil { + case "SecretValueRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName == nil { + case "SecretValueRemovedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID == nil { + case "SecretValueRemovedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message == nil { + case "SecretValueRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName == nil { + case "SecretValueRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType == nil { + case "SecretValueRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug == nil { + case "SecretValueRemovedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntryData.tokenName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName == nil { + case "SecretValueUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenEdge.cursor": - if e.ComplexityRoot.ServiceAccountTokenEdge.Cursor == nil { + case "SecretValueUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenEdge.node": - if e.ComplexityRoot.ServiceAccountTokenEdge.Node == nil { + case "SecretValueUpdatedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenEdge.Node(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor == nil { + case "SecretValueUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt == nil { + case "SecretValueUpdatedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data == nil { + case "SecretValueUpdatedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName == nil { + case "SecretValueUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID == nil { + case "SecretValueUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message == nil { + case "SecretValueUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName == nil { + case "SecretValueUpdatedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType == nil { + case "SecretValuesViewedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug == nil { + case "SecretValuesViewedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields == nil { + case "SecretValuesViewedActivityLogEntry.data": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "SecretValuesViewedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "SecretValuesViewedActivityLogEntry.id": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "SecretValuesViewedActivityLogEntry.message": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor == nil { + case "SecretValuesViewedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt == nil { + case "SecretValuesViewedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data == nil { + case "SecretValuesViewedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName == nil { + case "SecretValuesViewedActivityLogEntryData.reason": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID == nil { + case "ServiceAccount.createdAt": + if e.ComplexityRoot.ServiceAccount.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccount.CreatedAt(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message == nil { + case "ServiceAccount.description": + if e.ComplexityRoot.ServiceAccount.Description == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Description(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName == nil { + case "ServiceAccount.id": + if e.ComplexityRoot.ServiceAccount.ID == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccount.ID(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType == nil { + case "ServiceAccount.lastUsedAt": + if e.ComplexityRoot.ServiceAccount.LastUsedAt == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccount.LastUsedAt(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug == nil { + case "ServiceAccount.name": + if e.ComplexityRoot.ServiceAccount.Name == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Name(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields == nil { + case "ServiceAccount.roles": + if e.ComplexityRoot.ServiceAccount.Roles == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field == nil { - break + args, err := ec.field_ServiceAccount_roles_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "ServiceAccount.team": + if e.ComplexityRoot.ServiceAccount.Team == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Team(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "ServiceAccount.tokens": + if e.ComplexityRoot.ServiceAccount.Tokens == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + args, err := ec.field_ServiceAccount_tokens_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ServiceCostSample.cost": - if e.ComplexityRoot.ServiceCostSample.Cost == nil { + return e.ComplexityRoot.ServiceAccount.Tokens(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "ServiceAccount.updatedAt": + if e.ComplexityRoot.ServiceAccount.UpdatedAt == nil { break } - return e.ComplexityRoot.ServiceCostSample.Cost(childComplexity), true + return e.ComplexityRoot.ServiceAccount.UpdatedAt(childComplexity), true - case "ServiceCostSample.service": - if e.ComplexityRoot.ServiceCostSample.Service == nil { + case "ServiceAccountConnection.edges": + if e.ComplexityRoot.ServiceAccountConnection.Edges == nil { break } - return e.ComplexityRoot.ServiceCostSample.Service(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.Edges(childComplexity), true - case "ServiceCostSeries.date": - if e.ComplexityRoot.ServiceCostSeries.Date == nil { + case "ServiceAccountConnection.nodes": + if e.ComplexityRoot.ServiceAccountConnection.Nodes == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Date(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.Nodes(childComplexity), true - case "ServiceCostSeries.services": - if e.ComplexityRoot.ServiceCostSeries.Services == nil { + case "ServiceAccountConnection.pageInfo": + if e.ComplexityRoot.ServiceAccountConnection.PageInfo == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Services(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.PageInfo(childComplexity), true - case "ServiceCostSeries.sum": - if e.ComplexityRoot.ServiceCostSeries.Sum == nil { + case "ServiceAccountCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Sum(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.actor": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor == nil { + case "ServiceAccountCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt == nil { + case "ServiceAccountCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountCreatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.id": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID == nil { + case "ServiceAccountCreatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.message": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message == nil { + case "ServiceAccountCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName == nil { + case "ServiceAccountCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType == nil { + case "ServiceAccountCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug == nil { + case "ServiceAccountDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor(childComplexity), true - case "SetTeamMemberRolePayload.member": - if e.ComplexityRoot.SetTeamMemberRolePayload.Member == nil { + case "ServiceAccountDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SetTeamMemberRolePayload.Member(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlDatabase.charset": - if e.ComplexityRoot.SqlDatabase.Charset == nil { + case "ServiceAccountDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlDatabase.Charset(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlDatabase.collation": - if e.ComplexityRoot.SqlDatabase.Collation == nil { + case "ServiceAccountDeletedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlDatabase.Collation(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID(childComplexity), true - case "SqlDatabase.deletionPolicy": - if e.ComplexityRoot.SqlDatabase.DeletionPolicy == nil { + case "ServiceAccountDeletedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlDatabase.DeletionPolicy(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message(childComplexity), true - case "SqlDatabase.environment": - if e.ComplexityRoot.SqlDatabase.Environment == nil { + case "ServiceAccountDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlDatabase.Environment(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName(childComplexity), true - case "SqlDatabase.healthy": - if e.ComplexityRoot.SqlDatabase.Healthy == nil { + case "ServiceAccountDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlDatabase.Healthy(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType(childComplexity), true - case "SqlDatabase.id": - if e.ComplexityRoot.SqlDatabase.ID == nil { + case "ServiceAccountDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlDatabase.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlDatabase.name": - if e.ComplexityRoot.SqlDatabase.Name == nil { + case "ServiceAccountEdge.cursor": + if e.ComplexityRoot.ServiceAccountEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlDatabase.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountEdge.Cursor(childComplexity), true - case "SqlDatabase.team": - if e.ComplexityRoot.SqlDatabase.Team == nil { + case "ServiceAccountEdge.node": + if e.ComplexityRoot.ServiceAccountEdge.Node == nil { break } - return e.ComplexityRoot.SqlDatabase.Team(childComplexity), true + return e.ComplexityRoot.ServiceAccountEdge.Node(childComplexity), true - case "SqlDatabase.teamEnvironment": - if e.ComplexityRoot.SqlDatabase.TeamEnvironment == nil { + case "ServiceAccountToken.createdAt": + if e.ComplexityRoot.ServiceAccountToken.CreatedAt == nil { break } - return e.ComplexityRoot.SqlDatabase.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.CreatedAt(childComplexity), true - case "SqlInstance.auditLog": - if e.ComplexityRoot.SqlInstance.AuditLog == nil { + case "ServiceAccountToken.description": + if e.ComplexityRoot.ServiceAccountToken.Description == nil { break } - return e.ComplexityRoot.SqlInstance.AuditLog(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.Description(childComplexity), true - case "SqlInstance.backupConfiguration": - if e.ComplexityRoot.SqlInstance.BackupConfiguration == nil { + case "ServiceAccountToken.expiresAt": + if e.ComplexityRoot.ServiceAccountToken.ExpiresAt == nil { break } - return e.ComplexityRoot.SqlInstance.BackupConfiguration(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.ExpiresAt(childComplexity), true - case "SqlInstance.cascadingDelete": - if e.ComplexityRoot.SqlInstance.CascadingDelete == nil { + case "ServiceAccountToken.id": + if e.ComplexityRoot.ServiceAccountToken.ID == nil { break } - return e.ComplexityRoot.SqlInstance.CascadingDelete(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.ID(childComplexity), true - case "SqlInstance.connectionName": - if e.ComplexityRoot.SqlInstance.ConnectionName == nil { + case "ServiceAccountToken.lastUsedAt": + if e.ComplexityRoot.ServiceAccountToken.LastUsedAt == nil { break } - return e.ComplexityRoot.SqlInstance.ConnectionName(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.LastUsedAt(childComplexity), true - case "SqlInstance.cost": - if e.ComplexityRoot.SqlInstance.Cost == nil { + case "ServiceAccountToken.name": + if e.ComplexityRoot.ServiceAccountToken.Name == nil { break } - return e.ComplexityRoot.SqlInstance.Cost(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.Name(childComplexity), true - case "SqlInstance.database": - if e.ComplexityRoot.SqlInstance.Database == nil { + case "ServiceAccountToken.updatedAt": + if e.ComplexityRoot.ServiceAccountToken.UpdatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.Database(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.UpdatedAt(childComplexity), true - case "SqlInstance.diskAutoresize": - if e.ComplexityRoot.SqlInstance.DiskAutoresize == nil { + case "ServiceAccountTokenConnection.edges": + if e.ComplexityRoot.ServiceAccountTokenConnection.Edges == nil { break } - return e.ComplexityRoot.SqlInstance.DiskAutoresize(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.Edges(childComplexity), true - case "SqlInstance.diskAutoresizeLimit": - if e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit == nil { + case "ServiceAccountTokenConnection.nodes": + if e.ComplexityRoot.ServiceAccountTokenConnection.Nodes == nil { break } - return e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.Nodes(childComplexity), true - case "SqlInstance.environment": - if e.ComplexityRoot.SqlInstance.Environment == nil { + case "ServiceAccountTokenConnection.pageInfo": + if e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo == nil { break } - return e.ComplexityRoot.SqlInstance.Environment(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo(childComplexity), true - case "SqlInstance.flags": - if e.ComplexityRoot.SqlInstance.Flags == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor == nil { break } - args, err := ec.field_SqlInstance_flags_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Flags(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor(childComplexity), true - case "SqlInstance.healthy": - if e.ComplexityRoot.SqlInstance.Healthy == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.Healthy(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstance.highAvailability": - if e.ComplexityRoot.SqlInstance.HighAvailability == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstance.HighAvailability(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data(childComplexity), true - case "SqlInstance.id": - if e.ComplexityRoot.SqlInstance.ID == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstance.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstance.issues": - if e.ComplexityRoot.SqlInstance.Issues == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID == nil { break } - args, err := ec.field_SqlInstance_issues_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID(childComplexity), true - case "SqlInstance.maintenanceVersion": - if e.ComplexityRoot.SqlInstance.MaintenanceVersion == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstance.MaintenanceVersion(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message(childComplexity), true - case "SqlInstance.maintenanceWindow": - if e.ComplexityRoot.SqlInstance.MaintenanceWindow == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstance.MaintenanceWindow(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstance.metrics": - if e.ComplexityRoot.SqlInstance.Metrics == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstance.Metrics(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstance.name": - if e.ComplexityRoot.SqlInstance.Name == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstance.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstance.projectID": - if e.ComplexityRoot.SqlInstance.ProjectID == nil { + case "ServiceAccountTokenCreatedActivityLogEntryData.tokenName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName == nil { break } - return e.ComplexityRoot.SqlInstance.ProjectID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName(childComplexity), true - case "SqlInstance.state": - if e.ComplexityRoot.SqlInstance.State == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstance.State(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor(childComplexity), true - case "SqlInstance.status": - if e.ComplexityRoot.SqlInstance.Status == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.Status(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstance.team": - if e.ComplexityRoot.SqlInstance.Team == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstance.Team(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data(childComplexity), true - case "SqlInstance.teamEnvironment": - if e.ComplexityRoot.SqlInstance.TeamEnvironment == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstance.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstance.tier": - if e.ComplexityRoot.SqlInstance.Tier == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstance.Tier(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID(childComplexity), true - case "SqlInstance.users": - if e.ComplexityRoot.SqlInstance.Users == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message == nil { break } - args, err := ec.field_SqlInstance_users_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceUserOrder)), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message(childComplexity), true - case "SqlInstance.version": - if e.ComplexityRoot.SqlInstance.Version == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstance.Version(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstance.workload": - if e.ComplexityRoot.SqlInstance.Workload == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstance.Workload(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceBackupConfiguration.enabled": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceBackupConfiguration.pointInTimeRecovery": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery == nil { + case "ServiceAccountTokenDeletedActivityLogEntryData.tokenName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName(childComplexity), true - case "SqlInstanceBackupConfiguration.retainedBackups": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups == nil { + case "ServiceAccountTokenEdge.cursor": + if e.ComplexityRoot.ServiceAccountTokenEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenEdge.Cursor(childComplexity), true - case "SqlInstanceBackupConfiguration.startTime": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime == nil { + case "ServiceAccountTokenEdge.node": + if e.ComplexityRoot.ServiceAccountTokenEdge.Node == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenEdge.Node(childComplexity), true - case "SqlInstanceBackupConfiguration.transactionLogRetentionDays": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor(childComplexity), true - case "SqlInstanceConnection.edges": - if e.ComplexityRoot.SqlInstanceConnection.Edges == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstanceConnection.nodes": - if e.ComplexityRoot.SqlInstanceConnection.Nodes == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data(childComplexity), true - case "SqlInstanceConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceConnection.PageInfo == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstanceCost.sum": - if e.ComplexityRoot.SqlInstanceCost.Sum == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstanceCost.Sum(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID(childComplexity), true - case "SqlInstanceCpu.cores": - if e.ComplexityRoot.SqlInstanceCpu.Cores == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstanceCpu.Cores(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message(childComplexity), true - case "SqlInstanceCpu.utilization": - if e.ComplexityRoot.SqlInstanceCpu.Utilization == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceCpu.Utilization(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceDisk.quotaBytes": - if e.ComplexityRoot.SqlInstanceDisk.QuotaBytes == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceDisk.QuotaBytes(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceDisk.utilization": - if e.ComplexityRoot.SqlInstanceDisk.Utilization == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceDisk.Utilization(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceEdge.cursor": - if e.ComplexityRoot.SqlInstanceEdge.Cursor == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.SqlInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "SqlInstanceEdge.node": - if e.ComplexityRoot.SqlInstanceEdge.Node == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.SqlInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "SqlInstanceFlag.name": - if e.ComplexityRoot.SqlInstanceFlag.Name == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.SqlInstanceFlag.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "SqlInstanceFlag.value": - if e.ComplexityRoot.SqlInstanceFlag.Value == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.SqlInstanceFlag.Value(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "SqlInstanceFlagConnection.edges": - if e.ComplexityRoot.SqlInstanceFlagConnection.Edges == nil { + case "ServiceAccountUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor(childComplexity), true - case "SqlInstanceFlagConnection.nodes": - if e.ComplexityRoot.SqlInstanceFlagConnection.Nodes == nil { + case "ServiceAccountUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstanceFlagConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo == nil { + case "ServiceAccountUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data(childComplexity), true - case "SqlInstanceFlagEdge.cursor": - if e.ComplexityRoot.SqlInstanceFlagEdge.Cursor == nil { + case "ServiceAccountUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstanceFlagEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstanceFlagEdge.node": - if e.ComplexityRoot.SqlInstanceFlagEdge.Node == nil { + case "ServiceAccountUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstanceFlagEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID(childComplexity), true - case "SqlInstanceMaintenanceWindow.day": - if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day == nil { + case "ServiceAccountUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message(childComplexity), true - case "SqlInstanceMaintenanceWindow.hour": - if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour == nil { + case "ServiceAccountUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceMemory.quotaBytes": - if e.ComplexityRoot.SqlInstanceMemory.QuotaBytes == nil { + case "ServiceAccountUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceMemory.QuotaBytes(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceMemory.utilization": - if e.ComplexityRoot.SqlInstanceMemory.Utilization == nil { + case "ServiceAccountUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceMemory.Utilization(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceMetrics.cpu": - if e.ComplexityRoot.SqlInstanceMetrics.CPU == nil { + case "ServiceAccountUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.CPU(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "SqlInstanceMetrics.disk": - if e.ComplexityRoot.SqlInstanceMetrics.Disk == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.Disk(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "SqlInstanceMetrics.memory": - if e.ComplexityRoot.SqlInstanceMetrics.Memory == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.Memory(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "SqlInstanceStateIssue.id": - if e.ComplexityRoot.SqlInstanceStateIssue.ID == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "SqlInstanceStateIssue.message": - if e.ComplexityRoot.SqlInstanceStateIssue.Message == nil { + case "ServiceCostSample.cost": + if e.ComplexityRoot.ServiceCostSample.Cost == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.Message(childComplexity), true + return e.ComplexityRoot.ServiceCostSample.Cost(childComplexity), true - case "SqlInstanceStateIssue.sqlInstance": - if e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance == nil { + case "ServiceCostSample.service": + if e.ComplexityRoot.ServiceCostSample.Service == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance(childComplexity), true + return e.ComplexityRoot.ServiceCostSample.Service(childComplexity), true - case "SqlInstanceStateIssue.severity": - if e.ComplexityRoot.SqlInstanceStateIssue.Severity == nil { + case "ServiceCostSeries.date": + if e.ComplexityRoot.ServiceCostSeries.Date == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.Severity(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Date(childComplexity), true - case "SqlInstanceStateIssue.state": - if e.ComplexityRoot.SqlInstanceStateIssue.State == nil { + case "ServiceCostSeries.services": + if e.ComplexityRoot.ServiceCostSeries.Services == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.State(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Services(childComplexity), true - case "SqlInstanceStateIssue.teamEnvironment": - if e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment == nil { + case "ServiceCostSeries.sum": + if e.ComplexityRoot.ServiceCostSeries.Sum == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Sum(childComplexity), true - case "SqlInstanceStatus.privateIpAddress": - if e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress == nil { + case "ServiceMaintenanceActivityLogEntry.actor": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor(childComplexity), true - case "SqlInstanceStatus.publicIpAddress": - if e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress == nil { + case "ServiceMaintenanceActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstanceUser.authentication": - if e.ComplexityRoot.SqlInstanceUser.Authentication == nil { + case "ServiceMaintenanceActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstanceUser.Authentication(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstanceUser.name": - if e.ComplexityRoot.SqlInstanceUser.Name == nil { + case "ServiceMaintenanceActivityLogEntry.id": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstanceUser.Name(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID(childComplexity), true - case "SqlInstanceUserConnection.edges": - if e.ComplexityRoot.SqlInstanceUserConnection.Edges == nil { + case "ServiceMaintenanceActivityLogEntry.message": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message(childComplexity), true - case "SqlInstanceUserConnection.nodes": - if e.ComplexityRoot.SqlInstanceUserConnection.Nodes == nil { + case "ServiceMaintenanceActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceUserConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceUserConnection.PageInfo == nil { + case "ServiceMaintenanceActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceUserEdge.cursor": - if e.ComplexityRoot.SqlInstanceUserEdge.Cursor == nil { + case "ServiceMaintenanceActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceUserEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceUserEdge.node": - if e.ComplexityRoot.SqlInstanceUserEdge.Node == nil { + case "SetTeamMemberRolePayload.member": + if e.ComplexityRoot.SetTeamMemberRolePayload.Member == nil { break } - return e.ComplexityRoot.SqlInstanceUserEdge.Node(childComplexity), true + return e.ComplexityRoot.SetTeamMemberRolePayload.Member(childComplexity), true - case "SqlInstanceVersionIssue.id": - if e.ComplexityRoot.SqlInstanceVersionIssue.ID == nil { + case "SqlDatabase.charset": + if e.ComplexityRoot.SqlDatabase.Charset == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.ID(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Charset(childComplexity), true - case "SqlInstanceVersionIssue.message": - if e.ComplexityRoot.SqlInstanceVersionIssue.Message == nil { + case "SqlDatabase.collation": + if e.ComplexityRoot.SqlDatabase.Collation == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.Message(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Collation(childComplexity), true - case "SqlInstanceVersionIssue.sqlInstance": - if e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance == nil { + case "SqlDatabase.deletionPolicy": + if e.ComplexityRoot.SqlDatabase.DeletionPolicy == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance(childComplexity), true + return e.ComplexityRoot.SqlDatabase.DeletionPolicy(childComplexity), true - case "SqlInstanceVersionIssue.severity": - if e.ComplexityRoot.SqlInstanceVersionIssue.Severity == nil { + case "SqlDatabase.environment": + if e.ComplexityRoot.SqlDatabase.Environment == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.Severity(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Environment(childComplexity), true - case "SqlInstanceVersionIssue.teamEnvironment": - if e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment == nil { + case "SqlDatabase.healthy": + if e.ComplexityRoot.SqlDatabase.Healthy == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Healthy(childComplexity), true - case "StartOpenSearchMaintenancePayload.error": - if e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error == nil { + case "SqlDatabase.id": + if e.ComplexityRoot.SqlDatabase.ID == nil { break } - return e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error(childComplexity), true + return e.ComplexityRoot.SqlDatabase.ID(childComplexity), true - case "StartValkeyMaintenancePayload.error": - if e.ComplexityRoot.StartValkeyMaintenancePayload.Error == nil { + case "SqlDatabase.name": + if e.ComplexityRoot.SqlDatabase.Name == nil { break } - return e.ComplexityRoot.StartValkeyMaintenancePayload.Error(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Name(childComplexity), true - case "Subscription.log": - if e.ComplexityRoot.Subscription.Log == nil { + case "SqlDatabase.team": + if e.ComplexityRoot.SqlDatabase.Team == nil { break } - args, err := ec.field_Subscription_log_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlDatabase.Team(childComplexity), true + + case "SqlDatabase.teamEnvironment": + if e.ComplexityRoot.SqlDatabase.TeamEnvironment == nil { + break } - return e.ComplexityRoot.Subscription.Log(childComplexity, args["filter"].(loki.LogSubscriptionFilter)), true + return e.ComplexityRoot.SqlDatabase.TeamEnvironment(childComplexity), true - case "Subscription.workloadLog": - if e.ComplexityRoot.Subscription.WorkloadLog == nil { + case "SqlInstance.auditLog": + if e.ComplexityRoot.SqlInstance.AuditLog == nil { break } - args, err := ec.field_Subscription_workloadLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Subscription.WorkloadLog(childComplexity, args["filter"].(podlog.WorkloadLogSubscriptionFilter)), true + return e.ComplexityRoot.SqlInstance.AuditLog(childComplexity), true - case "Team.activityLog": - if e.ComplexityRoot.Team.ActivityLog == nil { + case "SqlInstance.backupConfiguration": + if e.ComplexityRoot.SqlInstance.BackupConfiguration == nil { break } - args, err := ec.field_Team_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.SqlInstance.BackupConfiguration(childComplexity), true - case "Team.alerts": - if e.ComplexityRoot.Team.Alerts == nil { + case "SqlInstance.cascadingDelete": + if e.ComplexityRoot.SqlInstance.CascadingDelete == nil { break } - args, err := ec.field_Team_alerts_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true + return e.ComplexityRoot.SqlInstance.CascadingDelete(childComplexity), true - case "Team.applications": - if e.ComplexityRoot.Team.Applications == nil { + case "SqlInstance.connectionName": + if e.ComplexityRoot.SqlInstance.ConnectionName == nil { break } - args, err := ec.field_Team_applications_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*application.ApplicationOrder), args["filter"].(*application.TeamApplicationsFilter)), true + return e.ComplexityRoot.SqlInstance.ConnectionName(childComplexity), true - case "Team.bigQueryDatasets": - if e.ComplexityRoot.Team.BigQueryDatasets == nil { + case "SqlInstance.cost": + if e.ComplexityRoot.SqlInstance.Cost == nil { break } - args, err := ec.field_Team_bigQueryDatasets_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Cost(childComplexity), true + + case "SqlInstance.database": + if e.ComplexityRoot.SqlInstance.Database == nil { + break } - return e.ComplexityRoot.Team.BigQueryDatasets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true + return e.ComplexityRoot.SqlInstance.Database(childComplexity), true - case "Team.buckets": - if e.ComplexityRoot.Team.Buckets == nil { + case "SqlInstance.diskAutoresize": + if e.ComplexityRoot.SqlInstance.DiskAutoresize == nil { break } - args, err := ec.field_Team_buckets_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.DiskAutoresize(childComplexity), true + + case "SqlInstance.diskAutoresizeLimit": + if e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit == nil { + break } - return e.ComplexityRoot.Team.Buckets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bucket.BucketOrder)), true + return e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit(childComplexity), true - case "Team.cost": - if e.ComplexityRoot.Team.Cost == nil { + case "SqlInstance.environment": + if e.ComplexityRoot.SqlInstance.Environment == nil { break } - return e.ComplexityRoot.Team.Cost(childComplexity), true + return e.ComplexityRoot.SqlInstance.Environment(childComplexity), true - case "Team.deleteKey": - if e.ComplexityRoot.Team.DeleteKey == nil { + case "SqlInstance.flags": + if e.ComplexityRoot.SqlInstance.Flags == nil { break } - args, err := ec.field_Team_deleteKey_args(ctx, rawArgs) + args, err := ec.field_SqlInstance_flags_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.DeleteKey(childComplexity, args["key"].(string)), true + return e.ComplexityRoot.SqlInstance.Flags(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Team.deletionInProgress": - if e.ComplexityRoot.Team.DeletionInProgress == nil { + case "SqlInstance.healthy": + if e.ComplexityRoot.SqlInstance.Healthy == nil { break } - return e.ComplexityRoot.Team.DeletionInProgress(childComplexity), true + return e.ComplexityRoot.SqlInstance.Healthy(childComplexity), true - case "Team.deploymentKey": - if e.ComplexityRoot.Team.DeploymentKey == nil { + case "SqlInstance.highAvailability": + if e.ComplexityRoot.SqlInstance.HighAvailability == nil { break } - return e.ComplexityRoot.Team.DeploymentKey(childComplexity), true + return e.ComplexityRoot.SqlInstance.HighAvailability(childComplexity), true - case "Team.deployments": - if e.ComplexityRoot.Team.Deployments == nil { + case "SqlInstance.id": + if e.ComplexityRoot.SqlInstance.ID == nil { break } - args, err := ec.field_Team_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.SqlInstance.ID(childComplexity), true - case "Team.environment": - if e.ComplexityRoot.Team.Environment == nil { + case "SqlInstance.issues": + if e.ComplexityRoot.SqlInstance.Issues == nil { break } - args, err := ec.field_Team_environment_args(ctx, rawArgs) + args, err := ec.field_SqlInstance_issues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.Environment(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.SqlInstance.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "Team.environments": - if e.ComplexityRoot.Team.Environments == nil { + case "SqlInstance.maintenanceVersion": + if e.ComplexityRoot.SqlInstance.MaintenanceVersion == nil { break } - return e.ComplexityRoot.Team.Environments(childComplexity), true + return e.ComplexityRoot.SqlInstance.MaintenanceVersion(childComplexity), true - case "Team.externalResources": - if e.ComplexityRoot.Team.ExternalResources == nil { + case "SqlInstance.maintenanceWindow": + if e.ComplexityRoot.SqlInstance.MaintenanceWindow == nil { break } - return e.ComplexityRoot.Team.ExternalResources(childComplexity), true + return e.ComplexityRoot.SqlInstance.MaintenanceWindow(childComplexity), true - case "Team.id": - if e.ComplexityRoot.Team.ID == nil { + case "SqlInstance.metrics": + if e.ComplexityRoot.SqlInstance.Metrics == nil { break } - return e.ComplexityRoot.Team.ID(childComplexity), true + return e.ComplexityRoot.SqlInstance.Metrics(childComplexity), true - case "Team.imageVulnerabilityHistory": - if e.ComplexityRoot.Team.ImageVulnerabilityHistory == nil { + case "SqlInstance.name": + if e.ComplexityRoot.SqlInstance.Name == nil { break } - args, err := ec.field_Team_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Name(childComplexity), true + + case "SqlInstance.projectID": + if e.ComplexityRoot.SqlInstance.ProjectID == nil { + break } - return e.ComplexityRoot.Team.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.SqlInstance.ProjectID(childComplexity), true - case "Team.inventoryCounts": - if e.ComplexityRoot.Team.InventoryCounts == nil { + case "SqlInstance.state": + if e.ComplexityRoot.SqlInstance.State == nil { break } - return e.ComplexityRoot.Team.InventoryCounts(childComplexity), true + return e.ComplexityRoot.SqlInstance.State(childComplexity), true - case "Team.issues": - if e.ComplexityRoot.Team.Issues == nil { + case "SqlInstance.status": + if e.ComplexityRoot.SqlInstance.Status == nil { break } - args, err := ec.field_Team_issues_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Status(childComplexity), true + + case "SqlInstance.team": + if e.ComplexityRoot.SqlInstance.Team == nil { + break } - return e.ComplexityRoot.Team.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.IssueFilter)), true + return e.ComplexityRoot.SqlInstance.Team(childComplexity), true - case "Team.jobs": - if e.ComplexityRoot.Team.Jobs == nil { + case "SqlInstance.teamEnvironment": + if e.ComplexityRoot.SqlInstance.TeamEnvironment == nil { break } - args, err := ec.field_Team_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.TeamEnvironment(childComplexity), true + + case "SqlInstance.tier": + if e.ComplexityRoot.SqlInstance.Tier == nil { + break } - return e.ComplexityRoot.Team.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*job.JobOrder), args["filter"].(*job.TeamJobsFilter)), true + return e.ComplexityRoot.SqlInstance.Tier(childComplexity), true - case "Team.kafkaTopics": - if e.ComplexityRoot.Team.KafkaTopics == nil { + case "SqlInstance.users": + if e.ComplexityRoot.SqlInstance.Users == nil { break } - args, err := ec.field_Team_kafkaTopics_args(ctx, rawArgs) + args, err := ec.field_SqlInstance_users_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.KafkaTopics(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*kafkatopic.KafkaTopicOrder)), true + return e.ComplexityRoot.SqlInstance.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceUserOrder)), true - case "Team.lastSuccessfulSync": - if e.ComplexityRoot.Team.LastSuccessfulSync == nil { + case "SqlInstance.version": + if e.ComplexityRoot.SqlInstance.Version == nil { break } - return e.ComplexityRoot.Team.LastSuccessfulSync(childComplexity), true + return e.ComplexityRoot.SqlInstance.Version(childComplexity), true - case "Team.member": - if e.ComplexityRoot.Team.Member == nil { + case "SqlInstance.workload": + if e.ComplexityRoot.SqlInstance.Workload == nil { break } - args, err := ec.field_Team_member_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Workload(childComplexity), true + + case "SqlInstanceBackupConfiguration.enabled": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled == nil { + break } - return e.ComplexityRoot.Team.Member(childComplexity, args["email"].(string)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled(childComplexity), true - case "Team.members": - if e.ComplexityRoot.Team.Members == nil { + case "SqlInstanceBackupConfiguration.pointInTimeRecovery": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery == nil { break } - args, err := ec.field_Team_members_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery(childComplexity), true + + case "SqlInstanceBackupConfiguration.retainedBackups": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups == nil { + break } - return e.ComplexityRoot.Team.Members(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamMemberOrder)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups(childComplexity), true - case "Team.openSearches": - if e.ComplexityRoot.Team.OpenSearches == nil { + case "SqlInstanceBackupConfiguration.startTime": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime == nil { break } - args, err := ec.field_Team_openSearches_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime(childComplexity), true + + case "SqlInstanceBackupConfiguration.transactionLogRetentionDays": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays == nil { + break } - return e.ComplexityRoot.Team.OpenSearches(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchOrder)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays(childComplexity), true - case "Team.postgresInstances": - if e.ComplexityRoot.Team.PostgresInstances == nil { + case "SqlInstanceConnection.edges": + if e.ComplexityRoot.SqlInstanceConnection.Edges == nil { break } - args, err := ec.field_Team_postgresInstances_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceConnection.Edges(childComplexity), true + + case "SqlInstanceConnection.nodes": + if e.ComplexityRoot.SqlInstanceConnection.Nodes == nil { + break } - return e.ComplexityRoot.Team.PostgresInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*postgres.PostgresInstanceOrder)), true + return e.ComplexityRoot.SqlInstanceConnection.Nodes(childComplexity), true - case "Team.purpose": - if e.ComplexityRoot.Team.Purpose == nil { + case "SqlInstanceConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.Team.Purpose(childComplexity), true + return e.ComplexityRoot.SqlInstanceConnection.PageInfo(childComplexity), true - case "Team.repositories": - if e.ComplexityRoot.Team.Repositories == nil { + case "SqlInstanceCost.sum": + if e.ComplexityRoot.SqlInstanceCost.Sum == nil { break } - args, err := ec.field_Team_repositories_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Repositories(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*repository.RepositoryOrder), args["filter"].(*repository.TeamRepositoryFilter)), true + return e.ComplexityRoot.SqlInstanceCost.Sum(childComplexity), true - case "Team.sqlInstances": - if e.ComplexityRoot.Team.SQLInstances == nil { + case "SqlInstanceCpu.cores": + if e.ComplexityRoot.SqlInstanceCpu.Cores == nil { break } - args, err := ec.field_Team_sqlInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.SQLInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + return e.ComplexityRoot.SqlInstanceCpu.Cores(childComplexity), true - case "Team.secrets": - if e.ComplexityRoot.Team.Secrets == nil { + case "SqlInstanceCpu.utilization": + if e.ComplexityRoot.SqlInstanceCpu.Utilization == nil { break } - args, err := ec.field_Team_secrets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*secret.SecretOrder), args["filter"].(*secret.SecretFilter)), true + return e.ComplexityRoot.SqlInstanceCpu.Utilization(childComplexity), true - case "Team.serviceUtilization": - if e.ComplexityRoot.Team.ServiceUtilization == nil { + case "SqlInstanceDisk.quotaBytes": + if e.ComplexityRoot.SqlInstanceDisk.QuotaBytes == nil { break } - return e.ComplexityRoot.Team.ServiceUtilization(childComplexity), true + return e.ComplexityRoot.SqlInstanceDisk.QuotaBytes(childComplexity), true - case "Team.slackChannel": - if e.ComplexityRoot.Team.SlackChannel == nil { + case "SqlInstanceDisk.utilization": + if e.ComplexityRoot.SqlInstanceDisk.Utilization == nil { break } - return e.ComplexityRoot.Team.SlackChannel(childComplexity), true + return e.ComplexityRoot.SqlInstanceDisk.Utilization(childComplexity), true - case "Team.slug": - if e.ComplexityRoot.Team.Slug == nil { + case "SqlInstanceEdge.cursor": + if e.ComplexityRoot.SqlInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.Team.Slug(childComplexity), true + return e.ComplexityRoot.SqlInstanceEdge.Cursor(childComplexity), true - case "Team.unleash": - if e.ComplexityRoot.Team.Unleash == nil { + case "SqlInstanceEdge.node": + if e.ComplexityRoot.SqlInstanceEdge.Node == nil { break } - return e.ComplexityRoot.Team.Unleash(childComplexity), true + return e.ComplexityRoot.SqlInstanceEdge.Node(childComplexity), true - case "Team.valkeys": - if e.ComplexityRoot.Team.Valkeys == nil { + case "SqlInstanceFlag.name": + if e.ComplexityRoot.SqlInstanceFlag.Name == nil { break } - args, err := ec.field_Team_valkeys_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Valkeys(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyOrder)), true + return e.ComplexityRoot.SqlInstanceFlag.Name(childComplexity), true - case "Team.viewerIsMember": - if e.ComplexityRoot.Team.ViewerIsMember == nil { + case "SqlInstanceFlag.value": + if e.ComplexityRoot.SqlInstanceFlag.Value == nil { break } - return e.ComplexityRoot.Team.ViewerIsMember(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlag.Value(childComplexity), true - case "Team.viewerIsOwner": - if e.ComplexityRoot.Team.ViewerIsOwner == nil { + case "SqlInstanceFlagConnection.edges": + if e.ComplexityRoot.SqlInstanceFlagConnection.Edges == nil { break } - return e.ComplexityRoot.Team.ViewerIsOwner(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlagConnection.Edges(childComplexity), true - case "Team.vulnerabilityFixHistory": - if e.ComplexityRoot.Team.VulnerabilityFixHistory == nil { + case "SqlInstanceFlagConnection.nodes": + if e.ComplexityRoot.SqlInstanceFlagConnection.Nodes == nil { break } - args, err := ec.field_Team_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.SqlInstanceFlagConnection.Nodes(childComplexity), true - case "Team.vulnerabilitySummaries": - if e.ComplexityRoot.Team.VulnerabilitySummaries == nil { + case "SqlInstanceFlagConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo == nil { break } - args, err := ec.field_Team_vulnerabilitySummaries_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.VulnerabilitySummaries(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter), args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.VulnerabilitySummaryOrder)), true + return e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo(childComplexity), true - case "Team.vulnerabilitySummary": - if e.ComplexityRoot.Team.VulnerabilitySummary == nil { + case "SqlInstanceFlagEdge.cursor": + if e.ComplexityRoot.SqlInstanceFlagEdge.Cursor == nil { break } - args, err := ec.field_Team_vulnerabilitySummary_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.VulnerabilitySummary(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter)), true + return e.ComplexityRoot.SqlInstanceFlagEdge.Cursor(childComplexity), true - case "Team.workloadUtilization": - if e.ComplexityRoot.Team.WorkloadUtilization == nil { + case "SqlInstanceFlagEdge.node": + if e.ComplexityRoot.SqlInstanceFlagEdge.Node == nil { break } - args, err := ec.field_Team_workloadUtilization_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.WorkloadUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.SqlInstanceFlagEdge.Node(childComplexity), true - case "Team.workloads": - if e.ComplexityRoot.Team.Workloads == nil { + case "SqlInstanceMaintenanceWindow.day": + if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day == nil { break } - args, err := ec.field_Team_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.WorkloadOrder), args["filter"].(*workload.TeamWorkloadsFilter)), true + return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day(childComplexity), true - case "TeamCDN.bucket": - if e.ComplexityRoot.TeamCDN.Bucket == nil { + case "SqlInstanceMaintenanceWindow.hour": + if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour == nil { break } - return e.ComplexityRoot.TeamCDN.Bucket(childComplexity), true + return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.actor": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor == nil { + case "SqlInstanceMemory.quotaBytes": + if e.ComplexityRoot.SqlInstanceMemory.QuotaBytes == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstanceMemory.QuotaBytes(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt == nil { + case "SqlInstanceMemory.utilization": + if e.ComplexityRoot.SqlInstanceMemory.Utilization == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SqlInstanceMemory.Utilization(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName == nil { + case "SqlInstanceMetrics.cpu": + if e.ComplexityRoot.SqlInstanceMetrics.CPU == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.CPU(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.id": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID == nil { + case "SqlInstanceMetrics.disk": + if e.ComplexityRoot.SqlInstanceMetrics.Disk == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.Disk(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.message": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message == nil { + case "SqlInstanceMetrics.memory": + if e.ComplexityRoot.SqlInstanceMetrics.Memory == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.Memory(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName == nil { + case "SqlInstanceStateIssue.id": + if e.ComplexityRoot.SqlInstanceStateIssue.ID == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.ID(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType == nil { + case "SqlInstanceStateIssue.message": + if e.ComplexityRoot.SqlInstanceStateIssue.Message == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.Message(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug == nil { + case "SqlInstanceStateIssue.sqlInstance": + if e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance(childComplexity), true - case "TeamConnection.edges": - if e.ComplexityRoot.TeamConnection.Edges == nil { + case "SqlInstanceStateIssue.severity": + if e.ComplexityRoot.SqlInstanceStateIssue.Severity == nil { break } - return e.ComplexityRoot.TeamConnection.Edges(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.Severity(childComplexity), true - case "TeamConnection.nodes": - if e.ComplexityRoot.TeamConnection.Nodes == nil { + case "SqlInstanceStateIssue.state": + if e.ComplexityRoot.SqlInstanceStateIssue.State == nil { break } - return e.ComplexityRoot.TeamConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.State(childComplexity), true - case "TeamConnection.pageInfo": - if e.ComplexityRoot.TeamConnection.PageInfo == nil { + case "SqlInstanceStateIssue.teamEnvironment": + if e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.TeamConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment(childComplexity), true - case "TeamCost.daily": - if e.ComplexityRoot.TeamCost.Daily == nil { + case "SqlInstanceStatus.privateIpAddress": + if e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress == nil { break } - args, err := ec.field_TeamCost_daily_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress(childComplexity), true + + case "SqlInstanceStatus.publicIpAddress": + if e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress == nil { + break } - return e.ComplexityRoot.TeamCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date), args["filter"].(*cost.TeamCostDailyFilter)), true + return e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress(childComplexity), true - case "TeamCost.monthlySummary": - if e.ComplexityRoot.TeamCost.MonthlySummary == nil { + case "SqlInstanceUser.authentication": + if e.ComplexityRoot.SqlInstanceUser.Authentication == nil { break } - return e.ComplexityRoot.TeamCost.MonthlySummary(childComplexity), true + return e.ComplexityRoot.SqlInstanceUser.Authentication(childComplexity), true - case "TeamCostMonthlySample.cost": - if e.ComplexityRoot.TeamCostMonthlySample.Cost == nil { + case "SqlInstanceUser.name": + if e.ComplexityRoot.SqlInstanceUser.Name == nil { break } - return e.ComplexityRoot.TeamCostMonthlySample.Cost(childComplexity), true + return e.ComplexityRoot.SqlInstanceUser.Name(childComplexity), true - case "TeamCostMonthlySample.date": - if e.ComplexityRoot.TeamCostMonthlySample.Date == nil { + case "SqlInstanceUserConnection.edges": + if e.ComplexityRoot.SqlInstanceUserConnection.Edges == nil { break } - return e.ComplexityRoot.TeamCostMonthlySample.Date(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.Edges(childComplexity), true - case "TeamCostMonthlySummary.series": - if e.ComplexityRoot.TeamCostMonthlySummary.Series == nil { + case "SqlInstanceUserConnection.nodes": + if e.ComplexityRoot.SqlInstanceUserConnection.Nodes == nil { break } - return e.ComplexityRoot.TeamCostMonthlySummary.Series(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.Nodes(childComplexity), true - case "TeamCostMonthlySummary.sum": - if e.ComplexityRoot.TeamCostMonthlySummary.Sum == nil { + case "SqlInstanceUserConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceUserConnection.PageInfo == nil { break } - return e.ComplexityRoot.TeamCostMonthlySummary.Sum(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.PageInfo(childComplexity), true - case "TeamCostPeriod.series": - if e.ComplexityRoot.TeamCostPeriod.Series == nil { + case "SqlInstanceUserEdge.cursor": + if e.ComplexityRoot.SqlInstanceUserEdge.Cursor == nil { break } - return e.ComplexityRoot.TeamCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserEdge.Cursor(childComplexity), true - case "TeamCostPeriod.sum": - if e.ComplexityRoot.TeamCostPeriod.Sum == nil { + case "SqlInstanceUserEdge.node": + if e.ComplexityRoot.SqlInstanceUserEdge.Node == nil { break } - return e.ComplexityRoot.TeamCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserEdge.Node(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.actor": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor == nil { + case "SqlInstanceVersionIssue.id": + if e.ComplexityRoot.SqlInstanceVersionIssue.ID == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.ID(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt == nil { + case "SqlInstanceVersionIssue.message": + if e.ComplexityRoot.SqlInstanceVersionIssue.Message == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.Message(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName == nil { + case "SqlInstanceVersionIssue.sqlInstance": + if e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.id": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID == nil { + case "SqlInstanceVersionIssue.severity": + if e.ComplexityRoot.SqlInstanceVersionIssue.Severity == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.Severity(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.message": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message == nil { + case "SqlInstanceVersionIssue.teamEnvironment": + if e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName == nil { + case "StartOpenSearchMaintenancePayload.error": + if e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType == nil { + case "StartValkeyMaintenancePayload.error": + if e.ComplexityRoot.StartValkeyMaintenancePayload.Error == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.StartValkeyMaintenancePayload.Error(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug == nil { + case "Subscription.log": + if e.ComplexityRoot.Subscription.Log == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamCreatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Subscription_log_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Subscription.Log(childComplexity, args["filter"].(loki.LogSubscriptionFilter)), true - case "TeamCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt == nil { + case "Subscription.workloadLog": + if e.ComplexityRoot.Subscription.WorkloadLog == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt(childComplexity), true - - case "TeamCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Subscription_workloadLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Subscription.WorkloadLog(childComplexity, args["filter"].(podlog.WorkloadLogSubscriptionFilter)), true - case "TeamCreatedActivityLogEntry.id": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ID == nil { + case "Team.activityLog": + if e.ComplexityRoot.Team.ActivityLog == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ID(childComplexity), true - - case "TeamCreatedActivityLogEntry.message": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.Message == nil { - break + args, err := ec.field_Team_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Team.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "TeamCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName == nil { + case "Team.alerts": + if e.ComplexityRoot.Team.Alerts == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName(childComplexity), true - - case "TeamCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Team_alerts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Team.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true - case "TeamCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug == nil { + case "Team.applications": + if e.ComplexityRoot.Team.Applications == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamDeleteKey.createdAt": - if e.ComplexityRoot.TeamDeleteKey.CreatedAt == nil { - break + args, err := ec.field_Team_applications_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.CreatedAt(childComplexity), true + return e.ComplexityRoot.Team.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*application.ApplicationOrder), args["filter"].(*application.TeamApplicationsFilter)), true - case "TeamDeleteKey.createdBy": - if e.ComplexityRoot.TeamDeleteKey.CreatedBy == nil { + case "Team.bigQueryDatasets": + if e.ComplexityRoot.Team.BigQueryDatasets == nil { break } - return e.ComplexityRoot.TeamDeleteKey.CreatedBy(childComplexity), true - - case "TeamDeleteKey.expires": - if e.ComplexityRoot.TeamDeleteKey.Expires == nil { - break + args, err := ec.field_Team_bigQueryDatasets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.Expires(childComplexity), true + return e.ComplexityRoot.Team.BigQueryDatasets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - case "TeamDeleteKey.key": - if e.ComplexityRoot.TeamDeleteKey.Key == nil { + case "Team.buckets": + if e.ComplexityRoot.Team.Buckets == nil { break } - return e.ComplexityRoot.TeamDeleteKey.Key(childComplexity), true - - case "TeamDeleteKey.team": - if e.ComplexityRoot.TeamDeleteKey.Team == nil { - break + args, err := ec.field_Team_buckets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.Team(childComplexity), true + return e.ComplexityRoot.Team.Buckets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bucket.BucketOrder)), true - case "TeamDeployKeyUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor == nil { + case "Team.configs": + if e.ComplexityRoot.Team.Configs == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor(childComplexity), true - - case "TeamDeployKeyUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Team_configs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Team.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*configmap.ConfigOrder), args["filter"].(*configmap.ConfigFilter)), true - case "TeamDeployKeyUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName == nil { + case "Team.cost": + if e.ComplexityRoot.Team.Cost == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Team.Cost(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID == nil { + case "Team.deleteKey": + if e.ComplexityRoot.Team.DeleteKey == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID(childComplexity), true + args, err := ec.field_Team_deleteKey_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamDeployKeyUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message == nil { + return e.ComplexityRoot.Team.DeleteKey(childComplexity, args["key"].(string)), true + + case "Team.deletionInProgress": + if e.ComplexityRoot.Team.DeletionInProgress == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Team.DeletionInProgress(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName == nil { + case "Team.deploymentKey": + if e.ComplexityRoot.Team.DeploymentKey == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Team.DeploymentKey(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType == nil { + case "Team.deployments": + if e.ComplexityRoot.Team.Deployments == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType(childComplexity), true + args, err := ec.field_Team_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamDeployKeyUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug == nil { + return e.ComplexityRoot.Team.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Team.environment": + if e.ComplexityRoot.Team.Environment == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true + args, err := ec.field_Team_environment_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamEdge.cursor": - if e.ComplexityRoot.TeamEdge.Cursor == nil { + return e.ComplexityRoot.Team.Environment(childComplexity, args["name"].(string)), true + + case "Team.environments": + if e.ComplexityRoot.Team.Environments == nil { break } - return e.ComplexityRoot.TeamEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Team.Environments(childComplexity), true - case "TeamEdge.node": - if e.ComplexityRoot.TeamEdge.Node == nil { + case "Team.externalResources": + if e.ComplexityRoot.Team.ExternalResources == nil { break } - return e.ComplexityRoot.TeamEdge.Node(childComplexity), true + return e.ComplexityRoot.Team.ExternalResources(childComplexity), true - case "TeamEntraIDGroup.groupID": - if e.ComplexityRoot.TeamEntraIDGroup.GroupID == nil { + case "Team.id": + if e.ComplexityRoot.Team.ID == nil { break } - return e.ComplexityRoot.TeamEntraIDGroup.GroupID(childComplexity), true + return e.ComplexityRoot.Team.ID(childComplexity), true - case "TeamEnvironment.alerts": - if e.ComplexityRoot.TeamEnvironment.Alerts == nil { + case "Team.imageVulnerabilityHistory": + if e.ComplexityRoot.Team.ImageVulnerabilityHistory == nil { break } - args, err := ec.field_TeamEnvironment_alerts_args(ctx, rawArgs) + args, err := ec.field_Team_imageVulnerabilityHistory_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true + return e.ComplexityRoot.Team.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true - case "TeamEnvironment.application": - if e.ComplexityRoot.TeamEnvironment.Application == nil { + case "Team.inventoryCounts": + if e.ComplexityRoot.Team.InventoryCounts == nil { break } - args, err := ec.field_TeamEnvironment_application_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Application(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.InventoryCounts(childComplexity), true - case "TeamEnvironment.bigQueryDataset": - if e.ComplexityRoot.TeamEnvironment.BigQueryDataset == nil { + case "Team.issues": + if e.ComplexityRoot.Team.Issues == nil { break } - args, err := ec.field_TeamEnvironment_bigQueryDataset_args(ctx, rawArgs) + args, err := ec.field_Team_issues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.BigQueryDataset(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.IssueFilter)), true - case "TeamEnvironment.bucket": - if e.ComplexityRoot.TeamEnvironment.Bucket == nil { + case "Team.jobs": + if e.ComplexityRoot.Team.Jobs == nil { break } - args, err := ec.field_TeamEnvironment_bucket_args(ctx, rawArgs) + args, err := ec.field_Team_jobs_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Bucket(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*job.JobOrder), args["filter"].(*job.TeamJobsFilter)), true - case "TeamEnvironment.cost": - if e.ComplexityRoot.TeamEnvironment.Cost == nil { + case "Team.kafkaTopics": + if e.ComplexityRoot.Team.KafkaTopics == nil { break } - return e.ComplexityRoot.TeamEnvironment.Cost(childComplexity), true + args, err := ec.field_Team_kafkaTopics_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamEnvironment.environment": - if e.ComplexityRoot.TeamEnvironment.Environment == nil { + return e.ComplexityRoot.Team.KafkaTopics(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*kafkatopic.KafkaTopicOrder)), true + + case "Team.lastSuccessfulSync": + if e.ComplexityRoot.Team.LastSuccessfulSync == nil { break } - return e.ComplexityRoot.TeamEnvironment.Environment(childComplexity), true + return e.ComplexityRoot.Team.LastSuccessfulSync(childComplexity), true - case "TeamEnvironment.gcpProjectID": - if e.ComplexityRoot.TeamEnvironment.GCPProjectID == nil { + case "Team.member": + if e.ComplexityRoot.Team.Member == nil { break } - return e.ComplexityRoot.TeamEnvironment.GCPProjectID(childComplexity), true + args, err := ec.field_Team_member_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamEnvironment.id": - if e.ComplexityRoot.TeamEnvironment.ID == nil { + return e.ComplexityRoot.Team.Member(childComplexity, args["email"].(string)), true + + case "Team.members": + if e.ComplexityRoot.Team.Members == nil { break } - return e.ComplexityRoot.TeamEnvironment.ID(childComplexity), true + args, err := ec.field_Team_members_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamEnvironment.job": - if e.ComplexityRoot.TeamEnvironment.Job == nil { + return e.ComplexityRoot.Team.Members(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamMemberOrder)), true + + case "Team.openSearches": + if e.ComplexityRoot.Team.OpenSearches == nil { break } - args, err := ec.field_TeamEnvironment_job_args(ctx, rawArgs) + args, err := ec.field_Team_openSearches_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Job(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.OpenSearches(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchOrder)), true - case "TeamEnvironment.kafkaTopic": - if e.ComplexityRoot.TeamEnvironment.KafkaTopic == nil { + case "Team.postgresInstances": + if e.ComplexityRoot.Team.PostgresInstances == nil { break } - args, err := ec.field_TeamEnvironment_kafkaTopic_args(ctx, rawArgs) + args, err := ec.field_Team_postgresInstances_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.KafkaTopic(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.PostgresInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*postgres.PostgresInstanceOrder)), true - case "TeamEnvironment.name": - if e.ComplexityRoot.TeamEnvironment.Name == nil { + case "Team.purpose": + if e.ComplexityRoot.Team.Purpose == nil { break } - return e.ComplexityRoot.TeamEnvironment.Name(childComplexity), true + return e.ComplexityRoot.Team.Purpose(childComplexity), true - case "TeamEnvironment.openSearch": - if e.ComplexityRoot.TeamEnvironment.OpenSearch == nil { + case "Team.repositories": + if e.ComplexityRoot.Team.Repositories == nil { break } - args, err := ec.field_TeamEnvironment_openSearch_args(ctx, rawArgs) + args, err := ec.field_Team_repositories_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.OpenSearch(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Repositories(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*repository.RepositoryOrder), args["filter"].(*repository.TeamRepositoryFilter)), true - case "TeamEnvironment.postgresInstance": - if e.ComplexityRoot.TeamEnvironment.PostgresInstance == nil { + case "Team.sqlInstances": + if e.ComplexityRoot.Team.SQLInstances == nil { break } - args, err := ec.field_TeamEnvironment_postgresInstance_args(ctx, rawArgs) + args, err := ec.field_Team_sqlInstances_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.PostgresInstance(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.SQLInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true - case "TeamEnvironment.sqlInstance": - if e.ComplexityRoot.TeamEnvironment.SQLInstance == nil { + case "Team.secrets": + if e.ComplexityRoot.Team.Secrets == nil { break } - args, err := ec.field_TeamEnvironment_sqlInstance_args(ctx, rawArgs) + args, err := ec.field_Team_secrets_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.SQLInstance(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*secret.SecretOrder), args["filter"].(*secret.SecretFilter)), true - case "TeamEnvironment.secret": - if e.ComplexityRoot.TeamEnvironment.Secret == nil { + case "Team.serviceUtilization": + if e.ComplexityRoot.Team.ServiceUtilization == nil { break } - args, err := ec.field_TeamEnvironment_secret_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Team.ServiceUtilization(childComplexity), true + + case "Team.slackChannel": + if e.ComplexityRoot.Team.SlackChannel == nil { + break } - return e.ComplexityRoot.TeamEnvironment.Secret(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.SlackChannel(childComplexity), true - case "TeamEnvironment.slackAlertsChannel": - if e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel == nil { + case "Team.slug": + if e.ComplexityRoot.Team.Slug == nil { break } - return e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel(childComplexity), true + return e.ComplexityRoot.Team.Slug(childComplexity), true - case "TeamEnvironment.team": - if e.ComplexityRoot.TeamEnvironment.Team == nil { + case "Team.unleash": + if e.ComplexityRoot.Team.Unleash == nil { break } - return e.ComplexityRoot.TeamEnvironment.Team(childComplexity), true + return e.ComplexityRoot.Team.Unleash(childComplexity), true - case "TeamEnvironment.valkey": - if e.ComplexityRoot.TeamEnvironment.Valkey == nil { + case "Team.valkeys": + if e.ComplexityRoot.Team.Valkeys == nil { break } - args, err := ec.field_TeamEnvironment_valkey_args(ctx, rawArgs) + args, err := ec.field_Team_valkeys_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Valkey(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Valkeys(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyOrder)), true - case "TeamEnvironment.workload": - if e.ComplexityRoot.TeamEnvironment.Workload == nil { + case "Team.viewerIsMember": + if e.ComplexityRoot.Team.ViewerIsMember == nil { break } - args, err := ec.field_TeamEnvironment_workload_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Team.ViewerIsMember(childComplexity), true + + case "Team.viewerIsOwner": + if e.ComplexityRoot.Team.ViewerIsOwner == nil { + break } - return e.ComplexityRoot.TeamEnvironment.Workload(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.ViewerIsOwner(childComplexity), true - case "TeamEnvironmentCost.daily": - if e.ComplexityRoot.TeamEnvironmentCost.Daily == nil { + case "Team.vulnerabilityFixHistory": + if e.ComplexityRoot.Team.VulnerabilityFixHistory == nil { break } - args, err := ec.field_TeamEnvironmentCost_daily_args(ctx, rawArgs) + args, err := ec.field_Team_vulnerabilityFixHistory_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironmentCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.Team.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "TeamEnvironmentCostPeriod.series": - if e.ComplexityRoot.TeamEnvironmentCostPeriod.Series == nil { + case "Team.vulnerabilitySummaries": + if e.ComplexityRoot.Team.VulnerabilitySummaries == nil { break } - return e.ComplexityRoot.TeamEnvironmentCostPeriod.Series(childComplexity), true - - case "TeamEnvironmentCostPeriod.sum": - if e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum == nil { - break + args, err := ec.field_Team_vulnerabilitySummaries_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.Team.VulnerabilitySummaries(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter), args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.VulnerabilitySummaryOrder)), true - case "TeamEnvironmentUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor == nil { + case "Team.vulnerabilitySummary": + if e.ComplexityRoot.Team.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Team_vulnerabilitySummary_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Team.VulnerabilitySummary(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter)), true - case "TeamEnvironmentUpdatedActivityLogEntry.data": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data == nil { + case "Team.workloadUtilization": + if e.ComplexityRoot.Team.WorkloadUtilization == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Team_workloadUtilization_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Team.WorkloadUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true - case "TeamEnvironmentUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID == nil { + case "Team.workloads": + if e.ComplexityRoot.Team.Workloads == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message == nil { - break + args, err := ec.field_Team_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Team.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.WorkloadOrder), args["filter"].(*workload.TeamWorkloadsFilter)), true - case "TeamEnvironmentUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName == nil { + case "TeamCDN.bucket": + if e.ComplexityRoot.TeamCDN.Bucket == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamCDN.Bucket(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.actor": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.id": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.message": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - case "TeamExternalResources.cdn": - if e.ComplexityRoot.TeamExternalResources.CDN == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamExternalResources.CDN(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType(childComplexity), true - case "TeamExternalResources.entraIDGroup": - if e.ComplexityRoot.TeamExternalResources.EntraIDGroup == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamExternalResources.EntraIDGroup(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - case "TeamExternalResources.gitHubTeam": - if e.ComplexityRoot.TeamExternalResources.GitHubTeam == nil { + case "TeamConnection.edges": + if e.ComplexityRoot.TeamConnection.Edges == nil { break } - return e.ComplexityRoot.TeamExternalResources.GitHubTeam(childComplexity), true + return e.ComplexityRoot.TeamConnection.Edges(childComplexity), true - case "TeamExternalResources.googleArtifactRegistry": - if e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry == nil { + case "TeamConnection.nodes": + if e.ComplexityRoot.TeamConnection.Nodes == nil { break } - return e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry(childComplexity), true + return e.ComplexityRoot.TeamConnection.Nodes(childComplexity), true - case "TeamExternalResources.googleGroup": - if e.ComplexityRoot.TeamExternalResources.GoogleGroup == nil { + case "TeamConnection.pageInfo": + if e.ComplexityRoot.TeamConnection.PageInfo == nil { break } - return e.ComplexityRoot.TeamExternalResources.GoogleGroup(childComplexity), true + return e.ComplexityRoot.TeamConnection.PageInfo(childComplexity), true - case "TeamGitHubTeam.slug": - if e.ComplexityRoot.TeamGitHubTeam.Slug == nil { + case "TeamCost.daily": + if e.ComplexityRoot.TeamCost.Daily == nil { break } - return e.ComplexityRoot.TeamGitHubTeam.Slug(childComplexity), true + args, err := ec.field_TeamCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamGoogleArtifactRegistry.repository": - if e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository == nil { + return e.ComplexityRoot.TeamCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date), args["filter"].(*cost.TeamCostDailyFilter)), true + + case "TeamCost.monthlySummary": + if e.ComplexityRoot.TeamCost.MonthlySummary == nil { break } - return e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository(childComplexity), true + return e.ComplexityRoot.TeamCost.MonthlySummary(childComplexity), true - case "TeamGoogleGroup.email": - if e.ComplexityRoot.TeamGoogleGroup.Email == nil { + case "TeamCostMonthlySample.cost": + if e.ComplexityRoot.TeamCostMonthlySample.Cost == nil { break } - return e.ComplexityRoot.TeamGoogleGroup.Email(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySample.Cost(childComplexity), true - case "TeamInventoryCountApplications.total": - if e.ComplexityRoot.TeamInventoryCountApplications.Total == nil { + case "TeamCostMonthlySample.date": + if e.ComplexityRoot.TeamCostMonthlySample.Date == nil { break } - return e.ComplexityRoot.TeamInventoryCountApplications.Total(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySample.Date(childComplexity), true - case "TeamInventoryCountBigQueryDatasets.total": - if e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total == nil { + case "TeamCostMonthlySummary.series": + if e.ComplexityRoot.TeamCostMonthlySummary.Series == nil { break } - return e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySummary.Series(childComplexity), true - case "TeamInventoryCountBuckets.total": - if e.ComplexityRoot.TeamInventoryCountBuckets.Total == nil { + case "TeamCostMonthlySummary.sum": + if e.ComplexityRoot.TeamCostMonthlySummary.Sum == nil { break } - return e.ComplexityRoot.TeamInventoryCountBuckets.Total(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySummary.Sum(childComplexity), true - case "TeamInventoryCountJobs.total": - if e.ComplexityRoot.TeamInventoryCountJobs.Total == nil { + case "TeamCostPeriod.series": + if e.ComplexityRoot.TeamCostPeriod.Series == nil { break } - return e.ComplexityRoot.TeamInventoryCountJobs.Total(childComplexity), true + return e.ComplexityRoot.TeamCostPeriod.Series(childComplexity), true - case "TeamInventoryCountKafkaTopics.total": - if e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total == nil { + case "TeamCostPeriod.sum": + if e.ComplexityRoot.TeamCostPeriod.Sum == nil { break } - return e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total(childComplexity), true + return e.ComplexityRoot.TeamCostPeriod.Sum(childComplexity), true - case "TeamInventoryCountOpenSearches.total": - if e.ComplexityRoot.TeamInventoryCountOpenSearches.Total == nil { + case "TeamCreateDeleteKeyActivityLogEntry.actor": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamInventoryCountOpenSearches.Total(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor(childComplexity), true - case "TeamInventoryCountPostgresInstances.total": - if e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total == nil { + case "TeamCreateDeleteKeyActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true - case "TeamInventoryCountSecrets.total": - if e.ComplexityRoot.TeamInventoryCountSecrets.Total == nil { + case "TeamCreateDeleteKeyActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamInventoryCountSecrets.Total(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamInventoryCountSqlInstances.total": - if e.ComplexityRoot.TeamInventoryCountSqlInstances.Total == nil { + case "TeamCreateDeleteKeyActivityLogEntry.id": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamInventoryCountSqlInstances.Total(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID(childComplexity), true - case "TeamInventoryCountValkeys.total": - if e.ComplexityRoot.TeamInventoryCountValkeys.Total == nil { + case "TeamCreateDeleteKeyActivityLogEntry.message": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamInventoryCountValkeys.Total(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message(childComplexity), true - case "TeamInventoryCounts.applications": - if e.ComplexityRoot.TeamInventoryCounts.Applications == nil { + case "TeamCreateDeleteKeyActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Applications(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - case "TeamInventoryCounts.bigQueryDatasets": - if e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets == nil { + case "TeamCreateDeleteKeyActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType(childComplexity), true - case "TeamInventoryCounts.buckets": - if e.ComplexityRoot.TeamInventoryCounts.Buckets == nil { + case "TeamCreateDeleteKeyActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Buckets(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - case "TeamInventoryCounts.jobs": - if e.ComplexityRoot.TeamInventoryCounts.Jobs == nil { + case "TeamCreatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Jobs(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor(childComplexity), true - case "TeamInventoryCounts.kafkaTopics": - if e.ComplexityRoot.TeamInventoryCounts.KafkaTopics == nil { + case "TeamCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.KafkaTopics(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamInventoryCounts.openSearches": - if e.ComplexityRoot.TeamInventoryCounts.OpenSearches == nil { + case "TeamCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.OpenSearches(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamInventoryCounts.postgresInstances": - if e.ComplexityRoot.TeamInventoryCounts.PostgresInstances == nil { + case "TeamCreatedActivityLogEntry.id": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.PostgresInstances(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ID(childComplexity), true - case "TeamInventoryCounts.sqlInstances": - if e.ComplexityRoot.TeamInventoryCounts.SQLInstances == nil { + case "TeamCreatedActivityLogEntry.message": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.SQLInstances(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.Message(childComplexity), true - case "TeamInventoryCounts.secrets": - if e.ComplexityRoot.TeamInventoryCounts.Secrets == nil { + case "TeamCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Secrets(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamInventoryCounts.valkeys": - if e.ComplexityRoot.TeamInventoryCounts.Valkeys == nil { + case "TeamCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Valkeys(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamMember.role": - if e.ComplexityRoot.TeamMember.Role == nil { + case "TeamCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamMember.Role(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamMember.team": - if e.ComplexityRoot.TeamMember.Team == nil { + case "TeamDeleteKey.createdAt": + if e.ComplexityRoot.TeamDeleteKey.CreatedAt == nil { break } - return e.ComplexityRoot.TeamMember.Team(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.CreatedAt(childComplexity), true - case "TeamMember.user": - if e.ComplexityRoot.TeamMember.User == nil { + case "TeamDeleteKey.createdBy": + if e.ComplexityRoot.TeamDeleteKey.CreatedBy == nil { break } - return e.ComplexityRoot.TeamMember.User(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.CreatedBy(childComplexity), true - case "TeamMemberAddedActivityLogEntry.actor": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor == nil { + case "TeamDeleteKey.expires": + if e.ComplexityRoot.TeamDeleteKey.Expires == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Expires(childComplexity), true - case "TeamMemberAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt == nil { + case "TeamDeleteKey.key": + if e.ComplexityRoot.TeamDeleteKey.Key == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Key(childComplexity), true - case "TeamMemberAddedActivityLogEntry.data": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data == nil { + case "TeamDeleteKey.team": + if e.ComplexityRoot.TeamDeleteKey.Team == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Team(childComplexity), true - case "TeamMemberAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor(childComplexity), true - case "TeamMemberAddedActivityLogEntry.id": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamMemberAddedActivityLogEntry.message": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamMemberAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID(childComplexity), true - case "TeamMemberAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message(childComplexity), true - case "TeamMemberAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamMemberAddedActivityLogEntryData.role": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamMemberAddedActivityLogEntryData.userEmail": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamMemberAddedActivityLogEntryData.userID": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID == nil { + case "TeamEdge.cursor": + if e.ComplexityRoot.TeamEdge.Cursor == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID(childComplexity), true + return e.ComplexityRoot.TeamEdge.Cursor(childComplexity), true - case "TeamMemberConnection.edges": - if e.ComplexityRoot.TeamMemberConnection.Edges == nil { + case "TeamEdge.node": + if e.ComplexityRoot.TeamEdge.Node == nil { break } - return e.ComplexityRoot.TeamMemberConnection.Edges(childComplexity), true + return e.ComplexityRoot.TeamEdge.Node(childComplexity), true - case "TeamMemberConnection.nodes": - if e.ComplexityRoot.TeamMemberConnection.Nodes == nil { + case "TeamEntraIDGroup.groupID": + if e.ComplexityRoot.TeamEntraIDGroup.GroupID == nil { break } - return e.ComplexityRoot.TeamMemberConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TeamEntraIDGroup.GroupID(childComplexity), true - case "TeamMemberConnection.pageInfo": - if e.ComplexityRoot.TeamMemberConnection.PageInfo == nil { + case "TeamEnvironment.alerts": + if e.ComplexityRoot.TeamEnvironment.Alerts == nil { break } - return e.ComplexityRoot.TeamMemberConnection.PageInfo(childComplexity), true - - case "TeamMemberEdge.cursor": - if e.ComplexityRoot.TeamMemberEdge.Cursor == nil { - break + args, err := ec.field_TeamEnvironment_alerts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true - case "TeamMemberEdge.node": - if e.ComplexityRoot.TeamMemberEdge.Node == nil { + case "TeamEnvironment.application": + if e.ComplexityRoot.TeamEnvironment.Application == nil { break } - return e.ComplexityRoot.TeamMemberEdge.Node(childComplexity), true - - case "TeamMemberRemovedActivityLogEntry.actor": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor == nil { - break + args, err := ec.field_TeamEnvironment_application_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Application(childComplexity, args["name"].(string)), true - case "TeamMemberRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt == nil { + case "TeamEnvironment.bigQueryDataset": + if e.ComplexityRoot.TeamEnvironment.BigQueryDataset == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt(childComplexity), true - - case "TeamMemberRemovedActivityLogEntry.data": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data == nil { - break + args, err := ec.field_TeamEnvironment_bigQueryDataset_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.BigQueryDataset(childComplexity, args["name"].(string)), true - case "TeamMemberRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName == nil { + case "TeamEnvironment.bucket": + if e.ComplexityRoot.TeamEnvironment.Bucket == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName(childComplexity), true - - case "TeamMemberRemovedActivityLogEntry.id": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID == nil { - break + args, err := ec.field_TeamEnvironment_bucket_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Bucket(childComplexity, args["name"].(string)), true - case "TeamMemberRemovedActivityLogEntry.message": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message == nil { + case "TeamEnvironment.config": + if e.ComplexityRoot.TeamEnvironment.Config == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message(childComplexity), true - - case "TeamMemberRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_TeamEnvironment_config_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Config(childComplexity, args["name"].(string)), true - case "TeamMemberRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType == nil { + case "TeamEnvironment.cost": + if e.ComplexityRoot.TeamEnvironment.Cost == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Cost(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug == nil { + case "TeamEnvironment.environment": + if e.ComplexityRoot.TeamEnvironment.Environment == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Environment(childComplexity), true - case "TeamMemberRemovedActivityLogEntryData.userEmail": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail == nil { + case "TeamEnvironment.gcpProjectID": + if e.ComplexityRoot.TeamEnvironment.GCPProjectID == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.GCPProjectID(childComplexity), true - case "TeamMemberRemovedActivityLogEntryData.userID": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID == nil { + case "TeamEnvironment.id": + if e.ComplexityRoot.TeamEnvironment.ID == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.ID(childComplexity), true - case "TeamMemberSetRoleActivityLogEntry.actor": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor == nil { + case "TeamEnvironment.job": + if e.ComplexityRoot.TeamEnvironment.Job == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_TeamEnvironment_job_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Job(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.data": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data == nil { + case "TeamEnvironment.kafkaTopic": + if e.ComplexityRoot.TeamEnvironment.KafkaTopic == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_TeamEnvironment_kafkaTopic_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.KafkaTopic(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.id": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID == nil { + case "TeamEnvironment.name": + if e.ComplexityRoot.TeamEnvironment.Name == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Name(childComplexity), true - case "TeamMemberSetRoleActivityLogEntry.message": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message == nil { + case "TeamEnvironment.openSearch": + if e.ComplexityRoot.TeamEnvironment.OpenSearch == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_TeamEnvironment_openSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.OpenSearch(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType == nil { + case "TeamEnvironment.postgresInstance": + if e.ComplexityRoot.TeamEnvironment.PostgresInstance == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_TeamEnvironment_postgresInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.PostgresInstance(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntryData.role": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role == nil { + case "TeamEnvironment.sqlInstance": + if e.ComplexityRoot.TeamEnvironment.SQLInstance == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntryData.userEmail": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail == nil { - break + args, err := ec.field_TeamEnvironment_sqlInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.SQLInstance(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntryData.userID": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID == nil { + case "TeamEnvironment.secret": + if e.ComplexityRoot.TeamEnvironment.Secret == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID(childComplexity), true - - case "TeamServiceUtilization.sqlInstances": - if e.ComplexityRoot.TeamServiceUtilization.SQLInstances == nil { - break + args, err := ec.field_TeamEnvironment_secret_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilization.SQLInstances(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Secret(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstances.cpu": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU == nil { + case "TeamEnvironment.slackAlertsChannel": + if e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel(childComplexity), true - case "TeamServiceUtilizationSqlInstances.disk": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk == nil { + case "TeamEnvironment.team": + if e.ComplexityRoot.TeamEnvironment.Team == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Team(childComplexity), true - case "TeamServiceUtilizationSqlInstances.memory": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory == nil { + case "TeamEnvironment.valkey": + if e.ComplexityRoot.TeamEnvironment.Valkey == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory(childComplexity), true - - case "TeamServiceUtilizationSqlInstancesCPU.requested": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested == nil { - break + args, err := ec.field_TeamEnvironment_valkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Valkey(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstancesCPU.used": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used == nil { + case "TeamEnvironment.workload": + if e.ComplexityRoot.TeamEnvironment.Workload == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used(childComplexity), true - - case "TeamServiceUtilizationSqlInstancesCPU.utilization": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization == nil { - break + args, err := ec.field_TeamEnvironment_workload_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Workload(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstancesDisk.requested": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested == nil { + case "TeamEnvironmentCost.daily": + if e.ComplexityRoot.TeamEnvironmentCost.Daily == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested(childComplexity), true + args, err := ec.field_TeamEnvironmentCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamServiceUtilizationSqlInstancesDisk.used": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used == nil { + return e.ComplexityRoot.TeamEnvironmentCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + + case "TeamEnvironmentCostPeriod.series": + if e.ComplexityRoot.TeamEnvironmentCostPeriod.Series == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCostPeriod.Series(childComplexity), true - case "TeamServiceUtilizationSqlInstancesDisk.utilization": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization == nil { + case "TeamEnvironmentCostPeriod.sum": + if e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum(childComplexity), true - case "TeamServiceUtilizationSqlInstancesMemory.requested": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor(childComplexity), true - case "TeamServiceUtilizationSqlInstancesMemory.used": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamServiceUtilizationSqlInstancesMemory.utilization": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.data": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data(childComplexity), true - case "TeamUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID(childComplexity), true - case "TeamUpdatedActivityLogEntry.data": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message(childComplexity), true - case "TeamUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName == nil { + case "TeamEnvironmentUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "TeamUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "TeamUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "TeamUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "TeamUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "TeamExternalResources.cdn": + if e.ComplexityRoot.TeamExternalResources.CDN == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.CDN(childComplexity), true - case "TeamUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "TeamExternalResources.entraIDGroup": + if e.ComplexityRoot.TeamExternalResources.EntraIDGroup == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.EntraIDGroup(childComplexity), true - case "TeamUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "TeamExternalResources.gitHubTeam": + if e.ComplexityRoot.TeamExternalResources.GitHubTeam == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GitHubTeam(childComplexity), true - case "TeamUtilizationData.environment": - if e.ComplexityRoot.TeamUtilizationData.Environment == nil { + case "TeamExternalResources.googleArtifactRegistry": + if e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Environment(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry(childComplexity), true - case "TeamUtilizationData.requested": - if e.ComplexityRoot.TeamUtilizationData.Requested == nil { + case "TeamExternalResources.googleGroup": + if e.ComplexityRoot.TeamExternalResources.GoogleGroup == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Requested(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GoogleGroup(childComplexity), true - case "TeamUtilizationData.team": - if e.ComplexityRoot.TeamUtilizationData.Team == nil { + case "TeamGitHubTeam.slug": + if e.ComplexityRoot.TeamGitHubTeam.Slug == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Team(childComplexity), true + return e.ComplexityRoot.TeamGitHubTeam.Slug(childComplexity), true - case "TeamUtilizationData.teamEnvironment": - if e.ComplexityRoot.TeamUtilizationData.TeamEnvironment == nil { + case "TeamGoogleArtifactRegistry.repository": + if e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository == nil { break } - return e.ComplexityRoot.TeamUtilizationData.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository(childComplexity), true - case "TeamUtilizationData.used": - if e.ComplexityRoot.TeamUtilizationData.Used == nil { + case "TeamGoogleGroup.email": + if e.ComplexityRoot.TeamGoogleGroup.Email == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Used(childComplexity), true + return e.ComplexityRoot.TeamGoogleGroup.Email(childComplexity), true - case "TeamVulnerabilitySummary.coverage": - if e.ComplexityRoot.TeamVulnerabilitySummary.Coverage == nil { + case "TeamInventoryCountApplications.total": + if e.ComplexityRoot.TeamInventoryCountApplications.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Coverage(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountApplications.Total(childComplexity), true - case "TeamVulnerabilitySummary.critical": - if e.ComplexityRoot.TeamVulnerabilitySummary.Critical == nil { + case "TeamInventoryCountBigQueryDatasets.total": + if e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Critical(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total(childComplexity), true - case "TeamVulnerabilitySummary.high": - if e.ComplexityRoot.TeamVulnerabilitySummary.High == nil { + case "TeamInventoryCountBuckets.total": + if e.ComplexityRoot.TeamInventoryCountBuckets.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountBuckets.Total(childComplexity), true - case "TeamVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated == nil { + case "TeamInventoryCountConfigs.total": + if e.ComplexityRoot.TeamInventoryCountConfigs.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountConfigs.Total(childComplexity), true - case "TeamVulnerabilitySummary.low": - if e.ComplexityRoot.TeamVulnerabilitySummary.Low == nil { + case "TeamInventoryCountJobs.total": + if e.ComplexityRoot.TeamInventoryCountJobs.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountJobs.Total(childComplexity), true - case "TeamVulnerabilitySummary.medium": - if e.ComplexityRoot.TeamVulnerabilitySummary.Medium == nil { + case "TeamInventoryCountKafkaTopics.total": + if e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total(childComplexity), true - case "TeamVulnerabilitySummary.riskScore": - if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore == nil { + case "TeamInventoryCountOpenSearches.total": + if e.ComplexityRoot.TeamInventoryCountOpenSearches.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountOpenSearches.Total(childComplexity), true - case "TeamVulnerabilitySummary.riskScoreTrend": - if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend == nil { + case "TeamInventoryCountPostgresInstances.total": + if e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total(childComplexity), true - case "TeamVulnerabilitySummary.sbomCount": - if e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount == nil { + case "TeamInventoryCountSecrets.total": + if e.ComplexityRoot.TeamInventoryCountSecrets.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountSecrets.Total(childComplexity), true - case "TeamVulnerabilitySummary.unassigned": - if e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned == nil { + case "TeamInventoryCountSqlInstances.total": + if e.ComplexityRoot.TeamInventoryCountSqlInstances.Total == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountSqlInstances.Total(childComplexity), true - case "TenantVulnerabilitySummary.coverage": - if e.ComplexityRoot.TenantVulnerabilitySummary.Coverage == nil { + case "TeamInventoryCountValkeys.total": + if e.ComplexityRoot.TeamInventoryCountValkeys.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Coverage(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountValkeys.Total(childComplexity), true - case "TenantVulnerabilitySummary.critical": - if e.ComplexityRoot.TenantVulnerabilitySummary.Critical == nil { + case "TeamInventoryCounts.applications": + if e.ComplexityRoot.TeamInventoryCounts.Applications == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Critical(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Applications(childComplexity), true - case "TenantVulnerabilitySummary.high": - if e.ComplexityRoot.TenantVulnerabilitySummary.High == nil { + case "TeamInventoryCounts.bigQueryDatasets": + if e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets(childComplexity), true - case "TenantVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated == nil { + case "TeamInventoryCounts.buckets": + if e.ComplexityRoot.TeamInventoryCounts.Buckets == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Buckets(childComplexity), true - case "TenantVulnerabilitySummary.low": - if e.ComplexityRoot.TenantVulnerabilitySummary.Low == nil { + case "TeamInventoryCounts.configs": + if e.ComplexityRoot.TeamInventoryCounts.Configs == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Configs(childComplexity), true - case "TenantVulnerabilitySummary.medium": - if e.ComplexityRoot.TenantVulnerabilitySummary.Medium == nil { + case "TeamInventoryCounts.jobs": + if e.ComplexityRoot.TeamInventoryCounts.Jobs == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Jobs(childComplexity), true - case "TenantVulnerabilitySummary.riskScore": - if e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore == nil { + case "TeamInventoryCounts.kafkaTopics": + if e.ComplexityRoot.TeamInventoryCounts.KafkaTopics == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.KafkaTopics(childComplexity), true - case "TenantVulnerabilitySummary.sbomCount": - if e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount == nil { + case "TeamInventoryCounts.openSearches": + if e.ComplexityRoot.TeamInventoryCounts.OpenSearches == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.OpenSearches(childComplexity), true - case "TenantVulnerabilitySummary.unassigned": - if e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned == nil { + case "TeamInventoryCounts.postgresInstances": + if e.ComplexityRoot.TeamInventoryCounts.PostgresInstances == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.PostgresInstances(childComplexity), true - case "TokenXAuthIntegration.name": - if e.ComplexityRoot.TokenXAuthIntegration.Name == nil { + case "TeamInventoryCounts.sqlInstances": + if e.ComplexityRoot.TeamInventoryCounts.SQLInstances == nil { break } - return e.ComplexityRoot.TokenXAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.SQLInstances(childComplexity), true - case "TriggerJobPayload.job": - if e.ComplexityRoot.TriggerJobPayload.Job == nil { + case "TeamInventoryCounts.secrets": + if e.ComplexityRoot.TeamInventoryCounts.Secrets == nil { break } - return e.ComplexityRoot.TriggerJobPayload.Job(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Secrets(childComplexity), true - case "TriggerJobPayload.jobRun": - if e.ComplexityRoot.TriggerJobPayload.JobRun == nil { + case "TeamInventoryCounts.valkeys": + if e.ComplexityRoot.TeamInventoryCounts.Valkeys == nil { break } - return e.ComplexityRoot.TriggerJobPayload.JobRun(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Valkeys(childComplexity), true - case "UnleashInstance.apiIngress": - if e.ComplexityRoot.UnleashInstance.APIIngress == nil { + case "TeamMember.role": + if e.ComplexityRoot.TeamMember.Role == nil { break } - return e.ComplexityRoot.UnleashInstance.APIIngress(childComplexity), true + return e.ComplexityRoot.TeamMember.Role(childComplexity), true - case "UnleashInstance.allowedTeams": - if e.ComplexityRoot.UnleashInstance.AllowedTeams == nil { + case "TeamMember.team": + if e.ComplexityRoot.TeamMember.Team == nil { break } - args, err := ec.field_UnleashInstance_allowedTeams_args(ctx, rawArgs) - if err != nil { - return 0, false - } + return e.ComplexityRoot.TeamMember.Team(childComplexity), true - return e.ComplexityRoot.UnleashInstance.AllowedTeams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - - case "UnleashInstance.id": - if e.ComplexityRoot.UnleashInstance.ID == nil { + case "TeamMember.user": + if e.ComplexityRoot.TeamMember.User == nil { break } - return e.ComplexityRoot.UnleashInstance.ID(childComplexity), true + return e.ComplexityRoot.TeamMember.User(childComplexity), true - case "UnleashInstance.metrics": - if e.ComplexityRoot.UnleashInstance.Metrics == nil { + case "TeamMemberAddedActivityLogEntry.actor": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UnleashInstance.Metrics(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor(childComplexity), true - case "UnleashInstance.name": - if e.ComplexityRoot.UnleashInstance.Name == nil { + case "TeamMemberAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UnleashInstance.Name(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt(childComplexity), true - case "UnleashInstance.ready": - if e.ComplexityRoot.UnleashInstance.Ready == nil { + case "TeamMemberAddedActivityLogEntry.data": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UnleashInstance.Ready(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data(childComplexity), true - case "UnleashInstance.releaseChannel": - if e.ComplexityRoot.UnleashInstance.ReleaseChannel == nil { + case "TeamMemberAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UnleashInstance.ReleaseChannel(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "UnleashInstance.releaseChannelName": - if e.ComplexityRoot.UnleashInstance.ReleaseChannelName == nil { + case "TeamMemberAddedActivityLogEntry.id": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UnleashInstance.ReleaseChannelName(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID(childComplexity), true - case "UnleashInstance.version": - if e.ComplexityRoot.UnleashInstance.Version == nil { + case "TeamMemberAddedActivityLogEntry.message": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UnleashInstance.Version(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message(childComplexity), true - case "UnleashInstance.webIngress": - if e.ComplexityRoot.UnleashInstance.WebIngress == nil { + case "TeamMemberAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UnleashInstance.WebIngress(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.actor": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor == nil { + case "TeamMemberAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt == nil { + case "TeamMemberAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName == nil { + case "TeamMemberAddedActivityLogEntryData.role": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.id": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID == nil { + case "TeamMemberAddedActivityLogEntryData.userEmail": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.message": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message == nil { + case "TeamMemberAddedActivityLogEntryData.userID": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName == nil { + case "TeamMemberConnection.edges": + if e.ComplexityRoot.TeamMemberConnection.Edges == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamMemberConnection.Edges(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType == nil { + case "TeamMemberConnection.nodes": + if e.ComplexityRoot.TeamMemberConnection.Nodes == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamMemberConnection.Nodes(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug == nil { + case "TeamMemberConnection.pageInfo": + if e.ComplexityRoot.TeamMemberConnection.PageInfo == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberConnection.PageInfo(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.actor": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor == nil { + case "TeamMemberEdge.cursor": + if e.ComplexityRoot.TeamMemberEdge.Cursor == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamMemberEdge.Cursor(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt == nil { + case "TeamMemberEdge.node": + if e.ComplexityRoot.TeamMemberEdge.Node == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamMemberEdge.Node(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName == nil { + case "TeamMemberRemovedActivityLogEntry.actor": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.id": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID == nil { + case "TeamMemberRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.message": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message == nil { + case "TeamMemberRemovedActivityLogEntry.data": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName == nil { + case "TeamMemberRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType == nil { + case "TeamMemberRemovedActivityLogEntry.id": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug == nil { + case "TeamMemberRemovedActivityLogEntry.message": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message(childComplexity), true - case "UnleashInstanceMetrics.apiTokens": - if e.ComplexityRoot.UnleashInstanceMetrics.APITokens == nil { + case "TeamMemberRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.APITokens(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName(childComplexity), true - case "UnleashInstanceMetrics.cpuRequests": - if e.ComplexityRoot.UnleashInstanceMetrics.CPURequests == nil { + case "TeamMemberRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.CPURequests(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType(childComplexity), true - case "UnleashInstanceMetrics.cpuUtilization": - if e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization == nil { + case "TeamMemberRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "UnleashInstanceMetrics.memoryRequests": - if e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests == nil { + case "TeamMemberRemovedActivityLogEntryData.userEmail": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail(childComplexity), true - case "UnleashInstanceMetrics.memoryUtilization": - if e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization == nil { + case "TeamMemberRemovedActivityLogEntryData.userID": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID(childComplexity), true - case "UnleashInstanceMetrics.toggles": - if e.ComplexityRoot.UnleashInstanceMetrics.Toggles == nil { + case "TeamMemberSetRoleActivityLogEntry.actor": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.Toggles(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor == nil { + case "TeamMemberSetRoleActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt == nil { + case "TeamMemberSetRoleActivityLogEntry.data": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.data": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data == nil { + case "TeamMemberSetRoleActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName == nil { + case "TeamMemberSetRoleActivityLogEntry.id": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.id": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID == nil { + case "TeamMemberSetRoleActivityLogEntry.message": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.message": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message == nil { + case "TeamMemberSetRoleActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName == nil { + case "TeamMemberSetRoleActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType == nil { + case "TeamMemberSetRoleActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug == nil { + case "TeamMemberSetRoleActivityLogEntryData.role": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntryData.allowedTeamSlug": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug == nil { + case "TeamMemberSetRoleActivityLogEntryData.userEmail": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntryData.revokedTeamSlug": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug == nil { + case "TeamMemberSetRoleActivityLogEntryData.userID": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntryData.updatedReleaseChannel": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel == nil { + case "TeamServiceUtilization.sqlInstances": + if e.ComplexityRoot.TeamServiceUtilization.SQLInstances == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilization.SQLInstances(childComplexity), true - case "UnleashReleaseChannel.currentVersion": - if e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion == nil { + case "TeamServiceUtilizationSqlInstances.cpu": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU(childComplexity), true - case "UnleashReleaseChannel.lastUpdated": - if e.ComplexityRoot.UnleashReleaseChannel.LastUpdated == nil { + case "TeamServiceUtilizationSqlInstances.disk": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.LastUpdated(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk(childComplexity), true - case "UnleashReleaseChannel.name": - if e.ComplexityRoot.UnleashReleaseChannel.Name == nil { + case "TeamServiceUtilizationSqlInstances.memory": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.Name(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory(childComplexity), true - case "UnleashReleaseChannel.type": - if e.ComplexityRoot.UnleashReleaseChannel.Type == nil { + case "TeamServiceUtilizationSqlInstancesCPU.requested": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.Type(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested(childComplexity), true - case "UnleashReleaseChannelIssue.channelName": - if e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName == nil { + case "TeamServiceUtilizationSqlInstancesCPU.used": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used(childComplexity), true - case "UnleashReleaseChannelIssue.currentMajorVersion": - if e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion == nil { + case "TeamServiceUtilizationSqlInstancesCPU.utilization": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization(childComplexity), true - case "UnleashReleaseChannelIssue.id": - if e.ComplexityRoot.UnleashReleaseChannelIssue.ID == nil { + case "TeamServiceUtilizationSqlInstancesDisk.requested": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.ID(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested(childComplexity), true - case "UnleashReleaseChannelIssue.majorVersion": - if e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion == nil { + case "TeamServiceUtilizationSqlInstancesDisk.used": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used(childComplexity), true - case "UnleashReleaseChannelIssue.message": - if e.ComplexityRoot.UnleashReleaseChannelIssue.Message == nil { + case "TeamServiceUtilizationSqlInstancesDisk.utilization": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.Message(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization(childComplexity), true - case "UnleashReleaseChannelIssue.severity": - if e.ComplexityRoot.UnleashReleaseChannelIssue.Severity == nil { + case "TeamServiceUtilizationSqlInstancesMemory.requested": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.Severity(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested(childComplexity), true - case "UnleashReleaseChannelIssue.teamEnvironment": - if e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment == nil { + case "TeamServiceUtilizationSqlInstancesMemory.used": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used(childComplexity), true - case "UnleashReleaseChannelIssue.unleash": - if e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash == nil { + case "TeamServiceUtilizationSqlInstancesMemory.utilization": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization(childComplexity), true - case "UpdateImageVulnerabilityPayload.vulnerability": - if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { + case "TeamUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor(childComplexity), true - case "UpdateOpenSearchPayload.openSearch": - if e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch == nil { + case "TeamUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "UpdateSecretValuePayload.secret": - if e.ComplexityRoot.UpdateSecretValuePayload.Secret == nil { + case "TeamUpdatedActivityLogEntry.data": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UpdateSecretValuePayload.Secret(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data(childComplexity), true - case "UpdateServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount == nil { + case "TeamUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "UpdateServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount == nil { + case "TeamUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID(childComplexity), true - case "UpdateServiceAccountTokenPayload.serviceAccountToken": - if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken == nil { + case "TeamUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message(childComplexity), true - case "UpdateTeamEnvironmentPayload.environment": - if e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment == nil { + case "TeamUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "UpdateTeamEnvironmentPayload.teamEnvironment": - if e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment == nil { + case "TeamUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "UpdateTeamPayload.team": - if e.ComplexityRoot.UpdateTeamPayload.Team == nil { + case "TeamUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UpdateTeamPayload.Team(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "UpdateUnleashInstancePayload.unleash": - if e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash == nil { + case "TeamUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "UpdateValkeyPayload.valkey": - if e.ComplexityRoot.UpdateValkeyPayload.Valkey == nil { + case "TeamUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.UpdateValkeyPayload.Valkey(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "User.email": - if e.ComplexityRoot.User.Email == nil { + case "TeamUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.User.Email(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "User.externalID": - if e.ComplexityRoot.User.ExternalID == nil { + case "TeamUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.User.ExternalID(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "User.id": - if e.ComplexityRoot.User.ID == nil { + case "TeamUtilizationData.environment": + if e.ComplexityRoot.TeamUtilizationData.Environment == nil { break } - return e.ComplexityRoot.User.ID(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Environment(childComplexity), true - case "User.isAdmin": - if e.ComplexityRoot.User.IsAdmin == nil { + case "TeamUtilizationData.requested": + if e.ComplexityRoot.TeamUtilizationData.Requested == nil { break } - return e.ComplexityRoot.User.IsAdmin(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Requested(childComplexity), true - case "User.name": - if e.ComplexityRoot.User.Name == nil { + case "TeamUtilizationData.team": + if e.ComplexityRoot.TeamUtilizationData.Team == nil { break } - return e.ComplexityRoot.User.Name(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Team(childComplexity), true - case "User.teams": - if e.ComplexityRoot.User.Teams == nil { + case "TeamUtilizationData.teamEnvironment": + if e.ComplexityRoot.TeamUtilizationData.TeamEnvironment == nil { break } - args, err := ec.field_User_teams_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamUtilizationData.TeamEnvironment(childComplexity), true + + case "TeamUtilizationData.used": + if e.ComplexityRoot.TeamUtilizationData.Used == nil { + break } - return e.ComplexityRoot.User.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.UserTeamOrder)), true + return e.ComplexityRoot.TeamUtilizationData.Used(childComplexity), true - case "UserConnection.edges": - if e.ComplexityRoot.UserConnection.Edges == nil { + case "TeamVulnerabilitySummary.coverage": + if e.ComplexityRoot.TeamVulnerabilitySummary.Coverage == nil { break } - return e.ComplexityRoot.UserConnection.Edges(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Coverage(childComplexity), true - case "UserConnection.nodes": - if e.ComplexityRoot.UserConnection.Nodes == nil { + case "TeamVulnerabilitySummary.critical": + if e.ComplexityRoot.TeamVulnerabilitySummary.Critical == nil { break } - return e.ComplexityRoot.UserConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Critical(childComplexity), true - case "UserConnection.pageInfo": - if e.ComplexityRoot.UserConnection.PageInfo == nil { + case "TeamVulnerabilitySummary.high": + if e.ComplexityRoot.TeamVulnerabilitySummary.High == nil { break } - return e.ComplexityRoot.UserConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.High(childComplexity), true - case "UserCreatedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt == nil { + case "TeamVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated(childComplexity), true - case "UserCreatedUserSyncLogEntry.id": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID == nil { + case "TeamVulnerabilitySummary.low": + if e.ComplexityRoot.TeamVulnerabilitySummary.Low == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Low(childComplexity), true - case "UserCreatedUserSyncLogEntry.message": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message == nil { + case "TeamVulnerabilitySummary.medium": + if e.ComplexityRoot.TeamVulnerabilitySummary.Medium == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Medium(childComplexity), true - case "UserCreatedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail == nil { + case "TeamVulnerabilitySummary.riskScore": + if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore(childComplexity), true - case "UserCreatedUserSyncLogEntry.userID": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID == nil { + case "TeamVulnerabilitySummary.riskScoreTrend": + if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend(childComplexity), true - case "UserCreatedUserSyncLogEntry.userName": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName == nil { + case "TeamVulnerabilitySummary.sbomCount": + if e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount(childComplexity), true - case "UserDeletedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt == nil { + case "TeamVulnerabilitySummary.unassigned": + if e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned(childComplexity), true - case "UserDeletedUserSyncLogEntry.id": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID == nil { + case "TenantVulnerabilitySummary.coverage": + if e.ComplexityRoot.TenantVulnerabilitySummary.Coverage == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Coverage(childComplexity), true - case "UserDeletedUserSyncLogEntry.message": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message == nil { + case "TenantVulnerabilitySummary.critical": + if e.ComplexityRoot.TenantVulnerabilitySummary.Critical == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Critical(childComplexity), true - case "UserDeletedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail == nil { + case "TenantVulnerabilitySummary.high": + if e.ComplexityRoot.TenantVulnerabilitySummary.High == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.High(childComplexity), true - case "UserDeletedUserSyncLogEntry.userID": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID == nil { + case "TenantVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated(childComplexity), true - case "UserDeletedUserSyncLogEntry.userName": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName == nil { + case "TenantVulnerabilitySummary.low": + if e.ComplexityRoot.TenantVulnerabilitySummary.Low == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Low(childComplexity), true - case "UserEdge.cursor": - if e.ComplexityRoot.UserEdge.Cursor == nil { + case "TenantVulnerabilitySummary.medium": + if e.ComplexityRoot.TenantVulnerabilitySummary.Medium == nil { break } - return e.ComplexityRoot.UserEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Medium(childComplexity), true - case "UserEdge.node": - if e.ComplexityRoot.UserEdge.Node == nil { + case "TenantVulnerabilitySummary.riskScore": + if e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore == nil { break } - return e.ComplexityRoot.UserEdge.Node(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore(childComplexity), true - case "UserSyncLogEntryConnection.edges": - if e.ComplexityRoot.UserSyncLogEntryConnection.Edges == nil { + case "TenantVulnerabilitySummary.sbomCount": + if e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount == nil { break } - return e.ComplexityRoot.UserSyncLogEntryConnection.Edges(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount(childComplexity), true - case "UserSyncLogEntryConnection.nodes": - if e.ComplexityRoot.UserSyncLogEntryConnection.Nodes == nil { + case "TenantVulnerabilitySummary.unassigned": + if e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.UserSyncLogEntryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned(childComplexity), true - case "UserSyncLogEntryConnection.pageInfo": - if e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo == nil { + case "TokenXAuthIntegration.name": + if e.ComplexityRoot.TokenXAuthIntegration.Name == nil { break } - return e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.TokenXAuthIntegration.Name(childComplexity), true - case "UserSyncLogEntryEdge.cursor": - if e.ComplexityRoot.UserSyncLogEntryEdge.Cursor == nil { + case "TriggerJobPayload.job": + if e.ComplexityRoot.TriggerJobPayload.Job == nil { break } - return e.ComplexityRoot.UserSyncLogEntryEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TriggerJobPayload.Job(childComplexity), true - case "UserSyncLogEntryEdge.node": - if e.ComplexityRoot.UserSyncLogEntryEdge.Node == nil { + case "TriggerJobPayload.jobRun": + if e.ComplexityRoot.TriggerJobPayload.JobRun == nil { break } - return e.ComplexityRoot.UserSyncLogEntryEdge.Node(childComplexity), true + return e.ComplexityRoot.TriggerJobPayload.JobRun(childComplexity), true - case "UserUpdatedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt == nil { + case "UnleashInstance.apiIngress": + if e.ComplexityRoot.UnleashInstance.APIIngress == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UnleashInstance.APIIngress(childComplexity), true - case "UserUpdatedUserSyncLogEntry.id": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID == nil { + case "UnleashInstance.allowedTeams": + if e.ComplexityRoot.UnleashInstance.AllowedTeams == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID(childComplexity), true - - case "UserUpdatedUserSyncLogEntry.message": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message == nil { - break + args, err := ec.field_UnleashInstance_allowedTeams_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UnleashInstance.AllowedTeams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "UserUpdatedUserSyncLogEntry.oldUserEmail": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail == nil { + case "UnleashInstance.id": + if e.ComplexityRoot.UnleashInstance.ID == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail(childComplexity), true + return e.ComplexityRoot.UnleashInstance.ID(childComplexity), true - case "UserUpdatedUserSyncLogEntry.oldUserName": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName == nil { + case "UnleashInstance.metrics": + if e.ComplexityRoot.UnleashInstance.Metrics == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Metrics(childComplexity), true - case "UserUpdatedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail == nil { + case "UnleashInstance.name": + if e.ComplexityRoot.UnleashInstance.Name == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Name(childComplexity), true - case "UserUpdatedUserSyncLogEntry.userID": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID == nil { + case "UnleashInstance.ready": + if e.ComplexityRoot.UnleashInstance.Ready == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Ready(childComplexity), true - case "UserUpdatedUserSyncLogEntry.userName": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName == nil { + case "UnleashInstance.releaseChannel": + if e.ComplexityRoot.UnleashInstance.ReleaseChannel == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.UnleashInstance.ReleaseChannel(childComplexity), true - case "UtilizationSample.instance": - if e.ComplexityRoot.UtilizationSample.Instance == nil { + case "UnleashInstance.releaseChannelName": + if e.ComplexityRoot.UnleashInstance.ReleaseChannelName == nil { break } - return e.ComplexityRoot.UtilizationSample.Instance(childComplexity), true + return e.ComplexityRoot.UnleashInstance.ReleaseChannelName(childComplexity), true - case "UtilizationSample.timestamp": - if e.ComplexityRoot.UtilizationSample.Timestamp == nil { + case "UnleashInstance.version": + if e.ComplexityRoot.UnleashInstance.Version == nil { break } - return e.ComplexityRoot.UtilizationSample.Timestamp(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Version(childComplexity), true - case "UtilizationSample.value": - if e.ComplexityRoot.UtilizationSample.Value == nil { + case "UnleashInstance.webIngress": + if e.ComplexityRoot.UnleashInstance.WebIngress == nil { break } - return e.ComplexityRoot.UtilizationSample.Value(childComplexity), true + return e.ComplexityRoot.UnleashInstance.WebIngress(childComplexity), true - case "Valkey.access": - if e.ComplexityRoot.Valkey.Access == nil { + case "UnleashInstanceCreatedActivityLogEntry.actor": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor == nil { break } - args, err := ec.field_Valkey_access_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Valkey.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyAccessOrder)), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor(childComplexity), true - case "Valkey.activityLog": - if e.ComplexityRoot.Valkey.ActivityLog == nil { + case "UnleashInstanceCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Valkey_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Valkey.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "Valkey.cost": - if e.ComplexityRoot.Valkey.Cost == nil { + case "UnleashInstanceCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Valkey.Cost(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "Valkey.environment": - if e.ComplexityRoot.Valkey.Environment == nil { + case "UnleashInstanceCreatedActivityLogEntry.id": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Valkey.Environment(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID(childComplexity), true - case "Valkey.id": - if e.ComplexityRoot.Valkey.ID == nil { + case "UnleashInstanceCreatedActivityLogEntry.message": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Valkey.ID(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message(childComplexity), true - case "Valkey.issues": - if e.ComplexityRoot.Valkey.Issues == nil { + case "UnleashInstanceCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Valkey_issues_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName(childComplexity), true + + case "UnleashInstanceCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType == nil { + break } - return e.ComplexityRoot.Valkey.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType(childComplexity), true - case "Valkey.maintenance": - if e.ComplexityRoot.Valkey.Maintenance == nil { + case "UnleashInstanceCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.Valkey.Maintenance(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "Valkey.maxMemoryPolicy": - if e.ComplexityRoot.Valkey.MaxMemoryPolicy == nil { + case "UnleashInstanceDeletedActivityLogEntry.actor": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.Valkey.MaxMemoryPolicy(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor(childComplexity), true - case "Valkey.memory": - if e.ComplexityRoot.Valkey.Memory == nil { + case "UnleashInstanceDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Valkey.Memory(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "Valkey.name": - if e.ComplexityRoot.Valkey.Name == nil { + case "UnleashInstanceDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Valkey.Name(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "Valkey.notifyKeyspaceEvents": - if e.ComplexityRoot.Valkey.NotifyKeyspaceEvents == nil { + case "UnleashInstanceDeletedActivityLogEntry.id": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Valkey.NotifyKeyspaceEvents(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID(childComplexity), true - case "Valkey.state": - if e.ComplexityRoot.Valkey.State == nil { + case "UnleashInstanceDeletedActivityLogEntry.message": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Valkey.State(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message(childComplexity), true - case "Valkey.team": - if e.ComplexityRoot.Valkey.Team == nil { + case "UnleashInstanceDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Valkey.Team(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName(childComplexity), true - case "Valkey.teamEnvironment": - if e.ComplexityRoot.Valkey.TeamEnvironment == nil { + case "UnleashInstanceDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Valkey.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType(childComplexity), true - case "Valkey.terminationProtection": - if e.ComplexityRoot.Valkey.TerminationProtection == nil { + case "UnleashInstanceDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.Valkey.TerminationProtection(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "Valkey.tier": - if e.ComplexityRoot.Valkey.Tier == nil { + case "UnleashInstanceMetrics.apiTokens": + if e.ComplexityRoot.UnleashInstanceMetrics.APITokens == nil { break } - return e.ComplexityRoot.Valkey.Tier(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.APITokens(childComplexity), true - case "Valkey.workload": - if e.ComplexityRoot.Valkey.Workload == nil { + case "UnleashInstanceMetrics.cpuRequests": + if e.ComplexityRoot.UnleashInstanceMetrics.CPURequests == nil { break } - return e.ComplexityRoot.Valkey.Workload(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.CPURequests(childComplexity), true - case "ValkeyAccess.access": - if e.ComplexityRoot.ValkeyAccess.Access == nil { + case "UnleashInstanceMetrics.cpuUtilization": + if e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization == nil { break } - return e.ComplexityRoot.ValkeyAccess.Access(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization(childComplexity), true - case "ValkeyAccess.workload": - if e.ComplexityRoot.ValkeyAccess.Workload == nil { + case "UnleashInstanceMetrics.memoryRequests": + if e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests == nil { break } - return e.ComplexityRoot.ValkeyAccess.Workload(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests(childComplexity), true - case "ValkeyAccessConnection.edges": - if e.ComplexityRoot.ValkeyAccessConnection.Edges == nil { + case "UnleashInstanceMetrics.memoryUtilization": + if e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization == nil { break } - return e.ComplexityRoot.ValkeyAccessConnection.Edges(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization(childComplexity), true - case "ValkeyAccessConnection.nodes": - if e.ComplexityRoot.ValkeyAccessConnection.Nodes == nil { + case "UnleashInstanceMetrics.toggles": + if e.ComplexityRoot.UnleashInstanceMetrics.Toggles == nil { break } - return e.ComplexityRoot.ValkeyAccessConnection.Nodes(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.Toggles(childComplexity), true - case "ValkeyAccessConnection.pageInfo": - if e.ComplexityRoot.ValkeyAccessConnection.PageInfo == nil { + case "UnleashInstanceUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ValkeyAccessConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor(childComplexity), true - case "ValkeyAccessEdge.cursor": - if e.ComplexityRoot.ValkeyAccessEdge.Cursor == nil { + case "UnleashInstanceUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ValkeyAccessEdge.Cursor(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ValkeyAccessEdge.node": - if e.ComplexityRoot.ValkeyAccessEdge.Node == nil { + case "UnleashInstanceUpdatedActivityLogEntry.data": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ValkeyAccessEdge.Node(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data(childComplexity), true - case "ValkeyConnection.edges": - if e.ComplexityRoot.ValkeyConnection.Edges == nil { + case "UnleashInstanceUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ValkeyConnection.Edges(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ValkeyConnection.nodes": - if e.ComplexityRoot.ValkeyConnection.Nodes == nil { + case "UnleashInstanceUpdatedActivityLogEntry.id": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ValkeyConnection.Nodes(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID(childComplexity), true - case "ValkeyConnection.pageInfo": - if e.ComplexityRoot.ValkeyConnection.PageInfo == nil { + case "UnleashInstanceUpdatedActivityLogEntry.message": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ValkeyConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message(childComplexity), true - case "ValkeyCost.sum": - if e.ComplexityRoot.ValkeyCost.Sum == nil { + case "UnleashInstanceUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ValkeyCost.Sum(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ValkeyCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor == nil { + case "UnleashInstanceUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ValkeyCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt == nil { + case "UnleashInstanceUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ValkeyCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName == nil { + case "UnleashInstanceUpdatedActivityLogEntryData.allowedTeamSlug": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug(childComplexity), true - case "ValkeyCreatedActivityLogEntry.id": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID == nil { + case "UnleashInstanceUpdatedActivityLogEntryData.revokedTeamSlug": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug(childComplexity), true - case "ValkeyCreatedActivityLogEntry.message": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message == nil { + case "UnleashInstanceUpdatedActivityLogEntryData.updatedReleaseChannel": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel(childComplexity), true - case "ValkeyCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName == nil { + case "UnleashReleaseChannel.currentVersion": + if e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion(childComplexity), true - case "ValkeyCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType == nil { + case "UnleashReleaseChannel.lastUpdated": + if e.ComplexityRoot.UnleashReleaseChannel.LastUpdated == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.LastUpdated(childComplexity), true - case "ValkeyCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug == nil { + case "UnleashReleaseChannel.name": + if e.ComplexityRoot.UnleashReleaseChannel.Name == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.Name(childComplexity), true - case "ValkeyCredentials.host": - if e.ComplexityRoot.ValkeyCredentials.Host == nil { + case "UnleashReleaseChannel.type": + if e.ComplexityRoot.UnleashReleaseChannel.Type == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Host(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.Type(childComplexity), true - case "ValkeyCredentials.password": - if e.ComplexityRoot.ValkeyCredentials.Password == nil { + case "UnleashReleaseChannelIssue.channelName": + if e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Password(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName(childComplexity), true - case "ValkeyCredentials.port": - if e.ComplexityRoot.ValkeyCredentials.Port == nil { + case "UnleashReleaseChannelIssue.currentMajorVersion": + if e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Port(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion(childComplexity), true - case "ValkeyCredentials.uri": - if e.ComplexityRoot.ValkeyCredentials.URI == nil { + case "UnleashReleaseChannelIssue.id": + if e.ComplexityRoot.UnleashReleaseChannelIssue.ID == nil { break } - return e.ComplexityRoot.ValkeyCredentials.URI(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.ID(childComplexity), true - case "ValkeyCredentials.username": - if e.ComplexityRoot.ValkeyCredentials.Username == nil { + case "UnleashReleaseChannelIssue.majorVersion": + if e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Username(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion(childComplexity), true - case "ValkeyDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor == nil { + case "UnleashReleaseChannelIssue.message": + if e.ComplexityRoot.UnleashReleaseChannelIssue.Message == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.Message(childComplexity), true - case "ValkeyDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt == nil { + case "UnleashReleaseChannelIssue.severity": + if e.ComplexityRoot.UnleashReleaseChannelIssue.Severity == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.Severity(childComplexity), true - case "ValkeyDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName == nil { + case "UnleashReleaseChannelIssue.teamEnvironment": + if e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment(childComplexity), true - case "ValkeyDeletedActivityLogEntry.id": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID == nil { + case "UnleashReleaseChannelIssue.unleash": + if e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash(childComplexity), true - case "ValkeyDeletedActivityLogEntry.message": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message == nil { + case "UpdateConfigValuePayload.config": + if e.ComplexityRoot.UpdateConfigValuePayload.Config == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UpdateConfigValuePayload.Config(childComplexity), true - case "ValkeyDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName == nil { + case "UpdateImageVulnerabilityPayload.vulnerability": + if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability(childComplexity), true - case "ValkeyDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType == nil { + case "UpdateOpenSearchPayload.openSearch": + if e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch(childComplexity), true - case "ValkeyDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug == nil { + case "UpdateSecretValuePayload.secret": + if e.ComplexityRoot.UpdateSecretValuePayload.Secret == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UpdateSecretValuePayload.Secret(childComplexity), true - case "ValkeyEdge.cursor": - if e.ComplexityRoot.ValkeyEdge.Cursor == nil { + case "UpdateServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ValkeyEdge.Cursor(childComplexity), true + return e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount(childComplexity), true - case "ValkeyEdge.node": - if e.ComplexityRoot.ValkeyEdge.Node == nil { + case "UpdateServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ValkeyEdge.Node(childComplexity), true + return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "ValkeyIssue.event": - if e.ComplexityRoot.ValkeyIssue.Event == nil { + case "UpdateServiceAccountTokenPayload.serviceAccountToken": + if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken == nil { break } - return e.ComplexityRoot.ValkeyIssue.Event(childComplexity), true + return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true - case "ValkeyIssue.id": - if e.ComplexityRoot.ValkeyIssue.ID == nil { + case "UpdateTeamEnvironmentPayload.environment": + if e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment == nil { break } - return e.ComplexityRoot.ValkeyIssue.ID(childComplexity), true + return e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment(childComplexity), true - case "ValkeyIssue.message": - if e.ComplexityRoot.ValkeyIssue.Message == nil { + case "UpdateTeamEnvironmentPayload.teamEnvironment": + if e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment == nil { break } - return e.ComplexityRoot.ValkeyIssue.Message(childComplexity), true + return e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment(childComplexity), true - case "ValkeyIssue.severity": - if e.ComplexityRoot.ValkeyIssue.Severity == nil { + case "UpdateTeamPayload.team": + if e.ComplexityRoot.UpdateTeamPayload.Team == nil { break } - return e.ComplexityRoot.ValkeyIssue.Severity(childComplexity), true + return e.ComplexityRoot.UpdateTeamPayload.Team(childComplexity), true - case "ValkeyIssue.teamEnvironment": - if e.ComplexityRoot.ValkeyIssue.TeamEnvironment == nil { + case "UpdateUnleashInstancePayload.unleash": + if e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash == nil { break } - return e.ComplexityRoot.ValkeyIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash(childComplexity), true - case "ValkeyIssue.valkey": - if e.ComplexityRoot.ValkeyIssue.Valkey == nil { + case "UpdateValkeyPayload.valkey": + if e.ComplexityRoot.UpdateValkeyPayload.Valkey == nil { break } - return e.ComplexityRoot.ValkeyIssue.Valkey(childComplexity), true + return e.ComplexityRoot.UpdateValkeyPayload.Valkey(childComplexity), true - case "ValkeyMaintenance.updates": - if e.ComplexityRoot.ValkeyMaintenance.Updates == nil { + case "User.email": + if e.ComplexityRoot.User.Email == nil { break } - args, err := ec.field_ValkeyMaintenance_updates_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.User.Email(childComplexity), true + + case "User.externalID": + if e.ComplexityRoot.User.ExternalID == nil { + break } - return e.ComplexityRoot.ValkeyMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.User.ExternalID(childComplexity), true - case "ValkeyMaintenance.window": - if e.ComplexityRoot.ValkeyMaintenance.Window == nil { + case "User.id": + if e.ComplexityRoot.User.ID == nil { break } - return e.ComplexityRoot.ValkeyMaintenance.Window(childComplexity), true + return e.ComplexityRoot.User.ID(childComplexity), true - case "ValkeyMaintenanceUpdate.deadline": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline == nil { + case "User.isAdmin": + if e.ComplexityRoot.User.IsAdmin == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline(childComplexity), true + return e.ComplexityRoot.User.IsAdmin(childComplexity), true - case "ValkeyMaintenanceUpdate.description": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.Description == nil { + case "User.name": + if e.ComplexityRoot.User.Name == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.Description(childComplexity), true + return e.ComplexityRoot.User.Name(childComplexity), true - case "ValkeyMaintenanceUpdate.startAt": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt == nil { + case "User.teams": + if e.ComplexityRoot.User.Teams == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt(childComplexity), true - - case "ValkeyMaintenanceUpdate.title": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.Title == nil { - break + args, err := ec.field_User_teams_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.Title(childComplexity), true + return e.ComplexityRoot.User.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.UserTeamOrder)), true - case "ValkeyMaintenanceUpdateConnection.edges": - if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges == nil { + case "UserConnection.edges": + if e.ComplexityRoot.UserConnection.Edges == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges(childComplexity), true + return e.ComplexityRoot.UserConnection.Edges(childComplexity), true - case "ValkeyMaintenanceUpdateConnection.nodes": - if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes == nil { + case "UserConnection.nodes": + if e.ComplexityRoot.UserConnection.Nodes == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes(childComplexity), true + return e.ComplexityRoot.UserConnection.Nodes(childComplexity), true - case "ValkeyMaintenanceUpdateConnection.pageInfo": - if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo == nil { + case "UserConnection.pageInfo": + if e.ComplexityRoot.UserConnection.PageInfo == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.UserConnection.PageInfo(childComplexity), true - case "ValkeyMaintenanceUpdateEdge.cursor": - if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor == nil { + case "UserCreatedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt(childComplexity), true - case "ValkeyMaintenanceUpdateEdge.node": - if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node == nil { + case "UserCreatedUserSyncLogEntry.id": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor == nil { + case "UserCreatedUserSyncLogEntry.message": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt == nil { + case "UserCreatedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data == nil { + case "UserCreatedUserSyncLogEntry.userID": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName == nil { + case "UserCreatedUserSyncLogEntry.userName": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID == nil { + case "UserDeletedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message == nil { + case "UserDeletedUserSyncLogEntry.id": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName == nil { + case "UserDeletedUserSyncLogEntry.message": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType == nil { + case "UserDeletedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug == nil { + case "UserDeletedUserSyncLogEntry.userID": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID(childComplexity), true - case "ValkeyUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields == nil { + case "UserDeletedUserSyncLogEntry.userName": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName(childComplexity), true - case "ValkeyUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "UserEdge.cursor": + if e.ComplexityRoot.UserEdge.Cursor == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.UserEdge.Cursor(childComplexity), true - case "ValkeyUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "UserEdge.node": + if e.ComplexityRoot.UserEdge.Node == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.UserEdge.Node(childComplexity), true - case "ValkeyUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "UserSyncLogEntryConnection.edges": + if e.ComplexityRoot.UserSyncLogEntryConnection.Edges == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryConnection.Edges(childComplexity), true - case "ViewSecretValuesPayload.values": - if e.ComplexityRoot.ViewSecretValuesPayload.Values == nil { + case "UserSyncLogEntryConnection.nodes": + if e.ComplexityRoot.UserSyncLogEntryConnection.Nodes == nil { break } - return e.ComplexityRoot.ViewSecretValuesPayload.Values(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryConnection.Nodes(childComplexity), true - case "VulnerabilityActivityLogEntryData.identifier": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier == nil { + case "UserSyncLogEntryConnection.pageInfo": + if e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo(childComplexity), true - case "VulnerabilityActivityLogEntryData.newSuppression": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression == nil { + case "UserSyncLogEntryEdge.cursor": + if e.ComplexityRoot.UserSyncLogEntryEdge.Cursor == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryEdge.Cursor(childComplexity), true - case "VulnerabilityActivityLogEntryData.package": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package == nil { + case "UserSyncLogEntryEdge.node": + if e.ComplexityRoot.UserSyncLogEntryEdge.Node == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryEdge.Node(childComplexity), true - case "VulnerabilityActivityLogEntryData.previousSuppression": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression == nil { + case "UserUpdatedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt(childComplexity), true - case "VulnerabilityActivityLogEntryData.severity": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity == nil { + case "UserUpdatedUserSyncLogEntry.id": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID(childComplexity), true - case "VulnerabilityFixHistory.samples": - if e.ComplexityRoot.VulnerabilityFixHistory.Samples == nil { + case "UserUpdatedUserSyncLogEntry.message": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.VulnerabilityFixHistory.Samples(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message(childComplexity), true - case "VulnerabilityFixSample.date": - if e.ComplexityRoot.VulnerabilityFixSample.Date == nil { + case "UserUpdatedUserSyncLogEntry.oldUserEmail": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.Date(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail(childComplexity), true - case "VulnerabilityFixSample.days": - if e.ComplexityRoot.VulnerabilityFixSample.Days == nil { + case "UserUpdatedUserSyncLogEntry.oldUserName": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.Days(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName(childComplexity), true - case "VulnerabilityFixSample.firstFixedAt": - if e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt == nil { + case "UserUpdatedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail(childComplexity), true - case "VulnerabilityFixSample.fixedCount": - if e.ComplexityRoot.VulnerabilityFixSample.FixedCount == nil { + case "UserUpdatedUserSyncLogEntry.userID": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.FixedCount(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID(childComplexity), true - case "VulnerabilityFixSample.lastFixedAt": - if e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt == nil { + case "UserUpdatedUserSyncLogEntry.userName": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName(childComplexity), true - case "VulnerabilityFixSample.severity": - if e.ComplexityRoot.VulnerabilityFixSample.Severity == nil { + case "UtilizationSample.instance": + if e.ComplexityRoot.UtilizationSample.Instance == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.Severity(childComplexity), true + return e.ComplexityRoot.UtilizationSample.Instance(childComplexity), true - case "VulnerabilityFixSample.totalWorkloads": - if e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads == nil { + case "UtilizationSample.timestamp": + if e.ComplexityRoot.UtilizationSample.Timestamp == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads(childComplexity), true + return e.ComplexityRoot.UtilizationSample.Timestamp(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor == nil { + case "UtilizationSample.value": + if e.ComplexityRoot.UtilizationSample.Value == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UtilizationSample.Value(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt == nil { + case "Valkey.access": + if e.ComplexityRoot.Valkey.Access == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt(childComplexity), true - - case "VulnerabilityUpdatedActivityLogEntry.data": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data == nil { - break + args, err := ec.field_Valkey_access_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.Valkey.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyAccessOrder)), true - case "VulnerabilityUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName == nil { + case "Valkey.activityLog": + if e.ComplexityRoot.Valkey.ActivityLog == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + args, err := ec.field_Valkey_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "VulnerabilityUpdatedActivityLogEntry.id": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID == nil { + return e.ComplexityRoot.Valkey.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + + case "Valkey.cost": + if e.ComplexityRoot.Valkey.Cost == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Valkey.Cost(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.message": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message == nil { + case "Valkey.environment": + if e.ComplexityRoot.Valkey.Environment == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Valkey.Environment(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName == nil { + case "Valkey.id": + if e.ComplexityRoot.Valkey.ID == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Valkey.ID(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType == nil { + case "Valkey.issues": + if e.ComplexityRoot.Valkey.Issues == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType(childComplexity), true + args, err := ec.field_Valkey_issues_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "VulnerabilityUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug == nil { + return e.ComplexityRoot.Valkey.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + + case "Valkey.maintenance": + if e.ComplexityRoot.Valkey.Maintenance == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Valkey.Maintenance(childComplexity), true - case "VulnerableImageIssue.critical": - if e.ComplexityRoot.VulnerableImageIssue.Critical == nil { + case "Valkey.maxMemoryPolicy": + if e.ComplexityRoot.Valkey.MaxMemoryPolicy == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Critical(childComplexity), true + return e.ComplexityRoot.Valkey.MaxMemoryPolicy(childComplexity), true - case "VulnerableImageIssue.id": - if e.ComplexityRoot.VulnerableImageIssue.ID == nil { + case "Valkey.memory": + if e.ComplexityRoot.Valkey.Memory == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.ID(childComplexity), true + return e.ComplexityRoot.Valkey.Memory(childComplexity), true - case "VulnerableImageIssue.message": - if e.ComplexityRoot.VulnerableImageIssue.Message == nil { + case "Valkey.name": + if e.ComplexityRoot.Valkey.Name == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Message(childComplexity), true + return e.ComplexityRoot.Valkey.Name(childComplexity), true - case "VulnerableImageIssue.riskScore": - if e.ComplexityRoot.VulnerableImageIssue.RiskScore == nil { + case "Valkey.notifyKeyspaceEvents": + if e.ComplexityRoot.Valkey.NotifyKeyspaceEvents == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.RiskScore(childComplexity), true + return e.ComplexityRoot.Valkey.NotifyKeyspaceEvents(childComplexity), true - case "VulnerableImageIssue.severity": - if e.ComplexityRoot.VulnerableImageIssue.Severity == nil { + case "Valkey.state": + if e.ComplexityRoot.Valkey.State == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Severity(childComplexity), true + return e.ComplexityRoot.Valkey.State(childComplexity), true - case "VulnerableImageIssue.teamEnvironment": - if e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment == nil { + case "Valkey.team": + if e.ComplexityRoot.Valkey.Team == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Valkey.Team(childComplexity), true - case "VulnerableImageIssue.workload": - if e.ComplexityRoot.VulnerableImageIssue.Workload == nil { + case "Valkey.teamEnvironment": + if e.ComplexityRoot.Valkey.TeamEnvironment == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Workload(childComplexity), true + return e.ComplexityRoot.Valkey.TeamEnvironment(childComplexity), true - case "WorkloadConnection.edges": - if e.ComplexityRoot.WorkloadConnection.Edges == nil { + case "Valkey.terminationProtection": + if e.ComplexityRoot.Valkey.TerminationProtection == nil { break } - return e.ComplexityRoot.WorkloadConnection.Edges(childComplexity), true + return e.ComplexityRoot.Valkey.TerminationProtection(childComplexity), true - case "WorkloadConnection.nodes": - if e.ComplexityRoot.WorkloadConnection.Nodes == nil { + case "Valkey.tier": + if e.ComplexityRoot.Valkey.Tier == nil { break } - return e.ComplexityRoot.WorkloadConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Valkey.Tier(childComplexity), true - case "WorkloadConnection.pageInfo": - if e.ComplexityRoot.WorkloadConnection.PageInfo == nil { + case "Valkey.workload": + if e.ComplexityRoot.Valkey.Workload == nil { break } - return e.ComplexityRoot.WorkloadConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Valkey.Workload(childComplexity), true - case "WorkloadCost.daily": - if e.ComplexityRoot.WorkloadCost.Daily == nil { + case "ValkeyAccess.access": + if e.ComplexityRoot.ValkeyAccess.Access == nil { break } - args, err := ec.field_WorkloadCost_daily_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyAccess.Access(childComplexity), true + + case "ValkeyAccess.workload": + if e.ComplexityRoot.ValkeyAccess.Workload == nil { + break } - return e.ComplexityRoot.WorkloadCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.ValkeyAccess.Workload(childComplexity), true - case "WorkloadCost.monthly": - if e.ComplexityRoot.WorkloadCost.Monthly == nil { + case "ValkeyAccessConnection.edges": + if e.ComplexityRoot.ValkeyAccessConnection.Edges == nil { break } - return e.ComplexityRoot.WorkloadCost.Monthly(childComplexity), true + return e.ComplexityRoot.ValkeyAccessConnection.Edges(childComplexity), true - case "WorkloadCostPeriod.series": - if e.ComplexityRoot.WorkloadCostPeriod.Series == nil { + case "ValkeyAccessConnection.nodes": + if e.ComplexityRoot.ValkeyAccessConnection.Nodes == nil { break } - return e.ComplexityRoot.WorkloadCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.ValkeyAccessConnection.Nodes(childComplexity), true - case "WorkloadCostPeriod.sum": - if e.ComplexityRoot.WorkloadCostPeriod.Sum == nil { + case "ValkeyAccessConnection.pageInfo": + if e.ComplexityRoot.ValkeyAccessConnection.PageInfo == nil { break } - return e.ComplexityRoot.WorkloadCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.ValkeyAccessConnection.PageInfo(childComplexity), true - case "WorkloadCostSample.cost": - if e.ComplexityRoot.WorkloadCostSample.Cost == nil { + case "ValkeyAccessEdge.cursor": + if e.ComplexityRoot.ValkeyAccessEdge.Cursor == nil { break } - return e.ComplexityRoot.WorkloadCostSample.Cost(childComplexity), true + return e.ComplexityRoot.ValkeyAccessEdge.Cursor(childComplexity), true - case "WorkloadCostSample.workload": - if e.ComplexityRoot.WorkloadCostSample.Workload == nil { + case "ValkeyAccessEdge.node": + if e.ComplexityRoot.ValkeyAccessEdge.Node == nil { break } - return e.ComplexityRoot.WorkloadCostSample.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyAccessEdge.Node(childComplexity), true - case "WorkloadCostSample.workloadName": - if e.ComplexityRoot.WorkloadCostSample.WorkloadName == nil { + case "ValkeyConnection.edges": + if e.ComplexityRoot.ValkeyConnection.Edges == nil { break } - return e.ComplexityRoot.WorkloadCostSample.WorkloadName(childComplexity), true + return e.ComplexityRoot.ValkeyConnection.Edges(childComplexity), true - case "WorkloadCostSeries.date": - if e.ComplexityRoot.WorkloadCostSeries.Date == nil { + case "ValkeyConnection.nodes": + if e.ComplexityRoot.ValkeyConnection.Nodes == nil { break } - return e.ComplexityRoot.WorkloadCostSeries.Date(childComplexity), true + return e.ComplexityRoot.ValkeyConnection.Nodes(childComplexity), true - case "WorkloadCostSeries.sum": - if e.ComplexityRoot.WorkloadCostSeries.Sum == nil { + case "ValkeyConnection.pageInfo": + if e.ComplexityRoot.ValkeyConnection.PageInfo == nil { break } - return e.ComplexityRoot.WorkloadCostSeries.Sum(childComplexity), true + return e.ComplexityRoot.ValkeyConnection.PageInfo(childComplexity), true - case "WorkloadCostSeries.workloads": - if e.ComplexityRoot.WorkloadCostSeries.Workloads == nil { + case "ValkeyCost.sum": + if e.ComplexityRoot.ValkeyCost.Sum == nil { break } - return e.ComplexityRoot.WorkloadCostSeries.Workloads(childComplexity), true + return e.ComplexityRoot.ValkeyCost.Sum(childComplexity), true - case "WorkloadEdge.cursor": - if e.ComplexityRoot.WorkloadEdge.Cursor == nil { + case "ValkeyCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.WorkloadEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor(childComplexity), true - case "WorkloadEdge.node": - if e.ComplexityRoot.WorkloadEdge.Node == nil { + case "ValkeyCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.WorkloadEdge.Node(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "WorkloadLogLine.instance": - if e.ComplexityRoot.WorkloadLogLine.Instance == nil { + case "ValkeyCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.WorkloadLogLine.Instance(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "WorkloadLogLine.message": - if e.ComplexityRoot.WorkloadLogLine.Message == nil { + case "ValkeyCreatedActivityLogEntry.id": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.WorkloadLogLine.Message(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID(childComplexity), true - case "WorkloadLogLine.time": - if e.ComplexityRoot.WorkloadLogLine.Time == nil { + case "ValkeyCreatedActivityLogEntry.message": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.WorkloadLogLine.Time(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message(childComplexity), true - case "WorkloadResourceQuantity.cpu": - if e.ComplexityRoot.WorkloadResourceQuantity.CPU == nil { + case "ValkeyCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.WorkloadResourceQuantity.CPU(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName(childComplexity), true - case "WorkloadResourceQuantity.memory": - if e.ComplexityRoot.WorkloadResourceQuantity.Memory == nil { + case "ValkeyCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.WorkloadResourceQuantity.Memory(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType(childComplexity), true - case "WorkloadUtilization.current": - if e.ComplexityRoot.WorkloadUtilization.Current == nil { + case "ValkeyCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_WorkloadUtilization_current_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug(childComplexity), true + + case "ValkeyCredentials.host": + if e.ComplexityRoot.ValkeyCredentials.Host == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.Current(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ValkeyCredentials.Host(childComplexity), true - case "WorkloadUtilization.limit": - if e.ComplexityRoot.WorkloadUtilization.Limit == nil { + case "ValkeyCredentials.password": + if e.ComplexityRoot.ValkeyCredentials.Password == nil { break } - args, err := ec.field_WorkloadUtilization_limit_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyCredentials.Password(childComplexity), true + + case "ValkeyCredentials.port": + if e.ComplexityRoot.ValkeyCredentials.Port == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.Limit(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ValkeyCredentials.Port(childComplexity), true - case "WorkloadUtilization.limitSeries": - if e.ComplexityRoot.WorkloadUtilization.LimitSeries == nil { + case "ValkeyCredentials.uri": + if e.ComplexityRoot.ValkeyCredentials.URI == nil { break } - args, err := ec.field_WorkloadUtilization_limitSeries_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyCredentials.URI(childComplexity), true + + case "ValkeyCredentials.username": + if e.ComplexityRoot.ValkeyCredentials.Username == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.LimitSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + return e.ComplexityRoot.ValkeyCredentials.Username(childComplexity), true - case "WorkloadUtilization.recommendations": - if e.ComplexityRoot.WorkloadUtilization.Recommendations == nil { + case "ValkeyDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.WorkloadUtilization.Recommendations(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor(childComplexity), true - case "WorkloadUtilization.requested": - if e.ComplexityRoot.WorkloadUtilization.Requested == nil { + case "ValkeyDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_WorkloadUtilization_requested_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt(childComplexity), true + + case "ValkeyDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.Requested(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "WorkloadUtilization.requestedSeries": - if e.ComplexityRoot.WorkloadUtilization.RequestedSeries == nil { + case "ValkeyDeletedActivityLogEntry.id": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID == nil { break } - args, err := ec.field_WorkloadUtilization_requestedSeries_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID(childComplexity), true + + case "ValkeyDeletedActivityLogEntry.message": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.RequestedSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message(childComplexity), true - case "WorkloadUtilization.series": - if e.ComplexityRoot.WorkloadUtilization.Series == nil { + case "ValkeyDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_WorkloadUtilization_series_args(ctx, rawArgs) + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName(childComplexity), true + + case "ValkeyDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType(childComplexity), true + + case "ValkeyDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug(childComplexity), true + + case "ValkeyEdge.cursor": + if e.ComplexityRoot.ValkeyEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.ValkeyEdge.Cursor(childComplexity), true + + case "ValkeyEdge.node": + if e.ComplexityRoot.ValkeyEdge.Node == nil { + break + } + + return e.ComplexityRoot.ValkeyEdge.Node(childComplexity), true + + case "ValkeyIssue.event": + if e.ComplexityRoot.ValkeyIssue.Event == nil { + break + } + + return e.ComplexityRoot.ValkeyIssue.Event(childComplexity), true + + case "ValkeyIssue.id": + if e.ComplexityRoot.ValkeyIssue.ID == nil { + break + } + + return e.ComplexityRoot.ValkeyIssue.ID(childComplexity), true + + case "ValkeyIssue.message": + if e.ComplexityRoot.ValkeyIssue.Message == nil { + break + } + + return e.ComplexityRoot.ValkeyIssue.Message(childComplexity), true + + case "ValkeyIssue.severity": + if e.ComplexityRoot.ValkeyIssue.Severity == nil { + break + } + + return e.ComplexityRoot.ValkeyIssue.Severity(childComplexity), true + + case "ValkeyIssue.teamEnvironment": + if e.ComplexityRoot.ValkeyIssue.TeamEnvironment == nil { + break + } + + return e.ComplexityRoot.ValkeyIssue.TeamEnvironment(childComplexity), true + + case "ValkeyIssue.valkey": + if e.ComplexityRoot.ValkeyIssue.Valkey == nil { + break + } + + return e.ComplexityRoot.ValkeyIssue.Valkey(childComplexity), true + + case "ValkeyMaintenance.updates": + if e.ComplexityRoot.ValkeyMaintenance.Updates == nil { + break + } + + args, err := ec.field_ValkeyMaintenance_updates_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.WorkloadUtilization.Series(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + return e.ComplexityRoot.ValkeyMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "WorkloadUtilizationData.requested": - if e.ComplexityRoot.WorkloadUtilizationData.Requested == nil { + case "ValkeyMaintenance.window": + if e.ComplexityRoot.ValkeyMaintenance.Window == nil { break } - return e.ComplexityRoot.WorkloadUtilizationData.Requested(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenance.Window(childComplexity), true - case "WorkloadUtilizationData.used": - if e.ComplexityRoot.WorkloadUtilizationData.Used == nil { + case "ValkeyMaintenanceUpdate.deadline": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline == nil { break } - return e.ComplexityRoot.WorkloadUtilizationData.Used(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline(childComplexity), true - case "WorkloadUtilizationData.workload": - if e.ComplexityRoot.WorkloadUtilizationData.Workload == nil { + case "ValkeyMaintenanceUpdate.description": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.Description == nil { break } - return e.ComplexityRoot.WorkloadUtilizationData.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdate.Description(childComplexity), true - case "WorkloadUtilizationRecommendations.cpuRequestCores": - if e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores == nil { + case "ValkeyMaintenanceUpdate.startAt": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt == nil { break } - return e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt(childComplexity), true - case "WorkloadUtilizationRecommendations.memoryLimitBytes": - if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes == nil { + case "ValkeyMaintenanceUpdate.title": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.Title == nil { break } - return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdate.Title(childComplexity), true - case "WorkloadUtilizationRecommendations.memoryRequestBytes": - if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes == nil { + case "ValkeyMaintenanceUpdateConnection.edges": + if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges == nil { break } - return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges(childComplexity), true - case "WorkloadVulnerabilitySummary.hasSBOM": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom == nil { + case "ValkeyMaintenanceUpdateConnection.nodes": + if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes(childComplexity), true - case "WorkloadVulnerabilitySummary.id": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.ID == nil { + case "ValkeyMaintenanceUpdateConnection.pageInfo": + if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.ID(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo(childComplexity), true - case "WorkloadVulnerabilitySummary.summary": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary == nil { + case "ValkeyMaintenanceUpdateEdge.cursor": + if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor(childComplexity), true - case "WorkloadVulnerabilitySummary.workload": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload == nil { + case "ValkeyMaintenanceUpdateEdge.node": + if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node(childComplexity), true - case "WorkloadVulnerabilitySummaryConnection.edges": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges == nil { + case "ValkeyUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor(childComplexity), true - case "WorkloadVulnerabilitySummaryConnection.nodes": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes == nil { + case "ValkeyUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "WorkloadVulnerabilitySummaryConnection.pageInfo": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo == nil { + case "ValkeyUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data(childComplexity), true - case "WorkloadVulnerabilitySummaryEdge.cursor": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor == nil { + case "ValkeyUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "WorkloadVulnerabilitySummaryEdge.node": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node == nil { + case "ValkeyUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID(childComplexity), true - case "WorkloadWithVulnerability.vulnerability": - if e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability == nil { + case "ValkeyUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message(childComplexity), true - case "WorkloadWithVulnerability.workload": - if e.ComplexityRoot.WorkloadWithVulnerability.Workload == nil { + case "ValkeyUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerability.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "WorkloadWithVulnerabilityConnection.edges": - if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges == nil { + case "ValkeyUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "WorkloadWithVulnerabilityConnection.nodes": - if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes == nil { + case "ValkeyUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "WorkloadWithVulnerabilityConnection.pageInfo": - if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo == nil { + case "ValkeyUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "WorkloadWithVulnerabilityEdge.cursor": - if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor == nil { + case "ValkeyUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "WorkloadWithVulnerabilityEdge.node": - if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node == nil { + case "ValkeyUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node(childComplexity), true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - } - return 0, false -} + case "ValkeyUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + break + } -func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { - opCtx := graphql.GetOperationContext(ctx) - ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult)) - inputUnmarshalMap := graphql.BuildUnmarshalerMap( - ec.unmarshalInputActivityLogFilter, - ec.unmarshalInputAddRepositoryToTeamInput, - ec.unmarshalInputAddSecretValueInput, - ec.unmarshalInputAddTeamMemberInput, - ec.unmarshalInputAlertOrder, - ec.unmarshalInputAllowTeamAccessToUnleashInput, - ec.unmarshalInputApplicationOrder, - ec.unmarshalInputAssignRoleToServiceAccountInput, - ec.unmarshalInputBigQueryDatasetAccessOrder, - ec.unmarshalInputBigQueryDatasetOrder, - ec.unmarshalInputBucketOrder, - ec.unmarshalInputCVEOrder, - ec.unmarshalInputChangeDeploymentKeyInput, - ec.unmarshalInputConfigureReconcilerInput, - ec.unmarshalInputConfirmTeamDeletionInput, - ec.unmarshalInputCreateKafkaCredentialsInput, - ec.unmarshalInputCreateOpenSearchCredentialsInput, - ec.unmarshalInputCreateOpenSearchInput, - ec.unmarshalInputCreateSecretInput, - ec.unmarshalInputCreateServiceAccountInput, - ec.unmarshalInputCreateServiceAccountTokenInput, - ec.unmarshalInputCreateTeamInput, - ec.unmarshalInputCreateUnleashForTeamInput, - ec.unmarshalInputCreateValkeyCredentialsInput, - ec.unmarshalInputCreateValkeyInput, - ec.unmarshalInputDeleteApplicationInput, - ec.unmarshalInputDeleteJobInput, - ec.unmarshalInputDeleteOpenSearchInput, - ec.unmarshalInputDeleteSecretInput, - ec.unmarshalInputDeleteServiceAccountInput, - ec.unmarshalInputDeleteServiceAccountTokenInput, - ec.unmarshalInputDeleteUnleashInstanceInput, - ec.unmarshalInputDeleteValkeyInput, - ec.unmarshalInputDeploymentFilter, - ec.unmarshalInputDeploymentOrder, - ec.unmarshalInputDisableReconcilerInput, - ec.unmarshalInputEnableReconcilerInput, - ec.unmarshalInputEnvironmentOrder, - ec.unmarshalInputEnvironmentWorkloadOrder, - ec.unmarshalInputGrantPostgresAccessInput, - ec.unmarshalInputImageVulnerabilityFilter, - ec.unmarshalInputImageVulnerabilityOrder, - ec.unmarshalInputIngressMetricsInput, - ec.unmarshalInputIssueFilter, - ec.unmarshalInputIssueOrder, - ec.unmarshalInputJobOrder, - ec.unmarshalInputKafkaTopicAclFilter, - ec.unmarshalInputKafkaTopicAclOrder, - ec.unmarshalInputKafkaTopicOrder, - ec.unmarshalInputLogSubscriptionFilter, - ec.unmarshalInputLogSubscriptionInitialBatch, - ec.unmarshalInputMetricsQueryInput, - ec.unmarshalInputMetricsRangeInput, - ec.unmarshalInputOpenSearchAccessOrder, - ec.unmarshalInputOpenSearchOrder, - ec.unmarshalInputPostgresInstanceOrder, - ec.unmarshalInputReconcilerConfigInput, - ec.unmarshalInputRemoveRepositoryFromTeamInput, - ec.unmarshalInputRemoveSecretValueInput, - ec.unmarshalInputRemoveTeamMemberInput, - ec.unmarshalInputRepositoryOrder, - ec.unmarshalInputRequestTeamDeletionInput, - ec.unmarshalInputResourceIssueFilter, - ec.unmarshalInputRestartApplicationInput, - ec.unmarshalInputRevokeRoleFromServiceAccountInput, - ec.unmarshalInputRevokeTeamAccessToUnleashInput, - ec.unmarshalInputSearchFilter, - ec.unmarshalInputSecretFilter, - ec.unmarshalInputSecretOrder, - ec.unmarshalInputSecretValueInput, - ec.unmarshalInputSetTeamMemberRoleInput, - ec.unmarshalInputSqlInstanceOrder, - ec.unmarshalInputSqlInstanceUserOrder, - ec.unmarshalInputStartOpenSearchMaintenanceInput, - ec.unmarshalInputStartValkeyMaintenanceInput, - ec.unmarshalInputTeamAlertsFilter, - ec.unmarshalInputTeamApplicationsFilter, - ec.unmarshalInputTeamCostDailyFilter, - ec.unmarshalInputTeamFilter, - ec.unmarshalInputTeamJobsFilter, - ec.unmarshalInputTeamMemberOrder, - ec.unmarshalInputTeamOrder, - ec.unmarshalInputTeamRepositoryFilter, - ec.unmarshalInputTeamVulnerabilitySummaryFilter, - ec.unmarshalInputTeamWorkloadsFilter, - ec.unmarshalInputTriggerJobInput, - ec.unmarshalInputUpdateImageVulnerabilityInput, - ec.unmarshalInputUpdateOpenSearchInput, - ec.unmarshalInputUpdateSecretValueInput, - ec.unmarshalInputUpdateServiceAccountInput, - ec.unmarshalInputUpdateServiceAccountTokenInput, - ec.unmarshalInputUpdateTeamEnvironmentInput, - ec.unmarshalInputUpdateTeamInput, - ec.unmarshalInputUpdateUnleashInstanceInput, - ec.unmarshalInputUpdateValkeyInput, - ec.unmarshalInputUserOrder, - ec.unmarshalInputUserTeamOrder, - ec.unmarshalInputValkeyAccessOrder, - ec.unmarshalInputValkeyOrder, - ec.unmarshalInputViewSecretValuesInput, - ec.unmarshalInputVulnerabilitySummaryOrder, - ec.unmarshalInputWorkloadLogSubscriptionFilter, - ec.unmarshalInputWorkloadOrder, - ec.unmarshalInputWorkloadUtilizationSeriesInput, - ) - first := true + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - switch opCtx.Operation.Operation { - case ast.Query: - return func(ctx context.Context) *graphql.Response { - var response graphql.Response - var data graphql.Marshaler - if first { - first = false - ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) - data = ec._Query(ctx, opCtx.Operation.SelectionSet) - } else { - if atomic.LoadInt32(&ec.PendingDeferred) > 0 { - result := <-ec.DeferredResults - atomic.AddInt32(&ec.PendingDeferred, -1) - data = result.Result - response.Path = result.Path - response.Label = result.Label - response.Errors = result.Errors - } else { - return nil - } - } - var buf bytes.Buffer - data.MarshalGQL(&buf) - response.Data = buf.Bytes() - if atomic.LoadInt32(&ec.Deferred) > 0 { - hasNext := atomic.LoadInt32(&ec.PendingDeferred) > 0 - response.HasNext = &hasNext - } + case "ViewSecretValuesPayload.values": + if e.ComplexityRoot.ViewSecretValuesPayload.Values == nil { + break + } - return &response + return e.ComplexityRoot.ViewSecretValuesPayload.Values(childComplexity), true + + case "VulnerabilityActivityLogEntryData.identifier": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier == nil { + break } - case ast.Mutation: - return func(ctx context.Context) *graphql.Response { - if !first { - return nil - } - first = false - ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) - data := ec._Mutation(ctx, opCtx.Operation.SelectionSet) - var buf bytes.Buffer - data.MarshalGQL(&buf) - return &graphql.Response{ - Data: buf.Bytes(), - } + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier(childComplexity), true + + case "VulnerabilityActivityLogEntryData.newSuppression": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression == nil { + break } - case ast.Subscription: - next := ec._Subscription(ctx, opCtx.Operation.SelectionSet) - var buf bytes.Buffer - return func(ctx context.Context) *graphql.Response { - buf.Reset() - data := next(ctx) + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression(childComplexity), true - if data == nil { - return nil - } - data.MarshalGQL(&buf) + case "VulnerabilityActivityLogEntryData.package": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package(childComplexity), true + + case "VulnerabilityActivityLogEntryData.previousSuppression": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression(childComplexity), true + + case "VulnerabilityActivityLogEntryData.severity": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity(childComplexity), true + + case "VulnerabilityFixHistory.samples": + if e.ComplexityRoot.VulnerabilityFixHistory.Samples == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixHistory.Samples(childComplexity), true + + case "VulnerabilityFixSample.date": + if e.ComplexityRoot.VulnerabilityFixSample.Date == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.Date(childComplexity), true + + case "VulnerabilityFixSample.days": + if e.ComplexityRoot.VulnerabilityFixSample.Days == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.Days(childComplexity), true + + case "VulnerabilityFixSample.firstFixedAt": + if e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt(childComplexity), true + + case "VulnerabilityFixSample.fixedCount": + if e.ComplexityRoot.VulnerabilityFixSample.FixedCount == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.FixedCount(childComplexity), true + + case "VulnerabilityFixSample.lastFixedAt": + if e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt(childComplexity), true + + case "VulnerabilityFixSample.severity": + if e.ComplexityRoot.VulnerabilityFixSample.Severity == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.Severity(childComplexity), true + + case "VulnerabilityFixSample.totalWorkloads": + if e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.data": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.id": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.message": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug(childComplexity), true + + case "VulnerableImageIssue.critical": + if e.ComplexityRoot.VulnerableImageIssue.Critical == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Critical(childComplexity), true + + case "VulnerableImageIssue.id": + if e.ComplexityRoot.VulnerableImageIssue.ID == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.ID(childComplexity), true + + case "VulnerableImageIssue.message": + if e.ComplexityRoot.VulnerableImageIssue.Message == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Message(childComplexity), true + + case "VulnerableImageIssue.riskScore": + if e.ComplexityRoot.VulnerableImageIssue.RiskScore == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.RiskScore(childComplexity), true + + case "VulnerableImageIssue.severity": + if e.ComplexityRoot.VulnerableImageIssue.Severity == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Severity(childComplexity), true + + case "VulnerableImageIssue.teamEnvironment": + if e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment(childComplexity), true + + case "VulnerableImageIssue.workload": + if e.ComplexityRoot.VulnerableImageIssue.Workload == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Workload(childComplexity), true + + case "WorkloadConnection.edges": + if e.ComplexityRoot.WorkloadConnection.Edges == nil { + break + } + + return e.ComplexityRoot.WorkloadConnection.Edges(childComplexity), true + + case "WorkloadConnection.nodes": + if e.ComplexityRoot.WorkloadConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.WorkloadConnection.Nodes(childComplexity), true + + case "WorkloadConnection.pageInfo": + if e.ComplexityRoot.WorkloadConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.WorkloadConnection.PageInfo(childComplexity), true + + case "WorkloadCost.daily": + if e.ComplexityRoot.WorkloadCost.Daily == nil { + break + } + + args, err := ec.field_WorkloadCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + + case "WorkloadCost.monthly": + if e.ComplexityRoot.WorkloadCost.Monthly == nil { + break + } + + return e.ComplexityRoot.WorkloadCost.Monthly(childComplexity), true + + case "WorkloadCostPeriod.series": + if e.ComplexityRoot.WorkloadCostPeriod.Series == nil { + break + } + + return e.ComplexityRoot.WorkloadCostPeriod.Series(childComplexity), true + + case "WorkloadCostPeriod.sum": + if e.ComplexityRoot.WorkloadCostPeriod.Sum == nil { + break + } + + return e.ComplexityRoot.WorkloadCostPeriod.Sum(childComplexity), true + + case "WorkloadCostSample.cost": + if e.ComplexityRoot.WorkloadCostSample.Cost == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSample.Cost(childComplexity), true + + case "WorkloadCostSample.workload": + if e.ComplexityRoot.WorkloadCostSample.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSample.Workload(childComplexity), true + + case "WorkloadCostSample.workloadName": + if e.ComplexityRoot.WorkloadCostSample.WorkloadName == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSample.WorkloadName(childComplexity), true + + case "WorkloadCostSeries.date": + if e.ComplexityRoot.WorkloadCostSeries.Date == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSeries.Date(childComplexity), true + + case "WorkloadCostSeries.sum": + if e.ComplexityRoot.WorkloadCostSeries.Sum == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSeries.Sum(childComplexity), true + + case "WorkloadCostSeries.workloads": + if e.ComplexityRoot.WorkloadCostSeries.Workloads == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSeries.Workloads(childComplexity), true + + case "WorkloadEdge.cursor": + if e.ComplexityRoot.WorkloadEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.WorkloadEdge.Cursor(childComplexity), true + + case "WorkloadEdge.node": + if e.ComplexityRoot.WorkloadEdge.Node == nil { + break + } + + return e.ComplexityRoot.WorkloadEdge.Node(childComplexity), true + + case "WorkloadLogLine.instance": + if e.ComplexityRoot.WorkloadLogLine.Instance == nil { + break + } + + return e.ComplexityRoot.WorkloadLogLine.Instance(childComplexity), true + + case "WorkloadLogLine.message": + if e.ComplexityRoot.WorkloadLogLine.Message == nil { + break + } + + return e.ComplexityRoot.WorkloadLogLine.Message(childComplexity), true + + case "WorkloadLogLine.time": + if e.ComplexityRoot.WorkloadLogLine.Time == nil { + break + } + + return e.ComplexityRoot.WorkloadLogLine.Time(childComplexity), true + + case "WorkloadResourceQuantity.cpu": + if e.ComplexityRoot.WorkloadResourceQuantity.CPU == nil { + break + } + + return e.ComplexityRoot.WorkloadResourceQuantity.CPU(childComplexity), true + + case "WorkloadResourceQuantity.memory": + if e.ComplexityRoot.WorkloadResourceQuantity.Memory == nil { + break + } + + return e.ComplexityRoot.WorkloadResourceQuantity.Memory(childComplexity), true + + case "WorkloadUtilization.current": + if e.ComplexityRoot.WorkloadUtilization.Current == nil { + break + } + + args, err := ec.field_WorkloadUtilization_current_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Current(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "WorkloadUtilization.limit": + if e.ComplexityRoot.WorkloadUtilization.Limit == nil { + break + } + + args, err := ec.field_WorkloadUtilization_limit_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Limit(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "WorkloadUtilization.limitSeries": + if e.ComplexityRoot.WorkloadUtilization.LimitSeries == nil { + break + } + + args, err := ec.field_WorkloadUtilization_limitSeries_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.LimitSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + + case "WorkloadUtilization.recommendations": + if e.ComplexityRoot.WorkloadUtilization.Recommendations == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilization.Recommendations(childComplexity), true + + case "WorkloadUtilization.requested": + if e.ComplexityRoot.WorkloadUtilization.Requested == nil { + break + } + + args, err := ec.field_WorkloadUtilization_requested_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Requested(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "WorkloadUtilization.requestedSeries": + if e.ComplexityRoot.WorkloadUtilization.RequestedSeries == nil { + break + } + + args, err := ec.field_WorkloadUtilization_requestedSeries_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.RequestedSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + + case "WorkloadUtilization.series": + if e.ComplexityRoot.WorkloadUtilization.Series == nil { + break + } + + args, err := ec.field_WorkloadUtilization_series_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Series(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + + case "WorkloadUtilizationData.requested": + if e.ComplexityRoot.WorkloadUtilizationData.Requested == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationData.Requested(childComplexity), true + + case "WorkloadUtilizationData.used": + if e.ComplexityRoot.WorkloadUtilizationData.Used == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationData.Used(childComplexity), true + + case "WorkloadUtilizationData.workload": + if e.ComplexityRoot.WorkloadUtilizationData.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationData.Workload(childComplexity), true + + case "WorkloadUtilizationRecommendations.cpuRequestCores": + if e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores(childComplexity), true + + case "WorkloadUtilizationRecommendations.memoryLimitBytes": + if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes(childComplexity), true + + case "WorkloadUtilizationRecommendations.memoryRequestBytes": + if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes(childComplexity), true + + case "WorkloadVulnerabilitySummary.hasSBOM": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom(childComplexity), true + + case "WorkloadVulnerabilitySummary.id": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.ID == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.ID(childComplexity), true + + case "WorkloadVulnerabilitySummary.summary": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary(childComplexity), true + + case "WorkloadVulnerabilitySummary.workload": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload(childComplexity), true + + case "WorkloadVulnerabilitySummaryConnection.edges": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges(childComplexity), true + + case "WorkloadVulnerabilitySummaryConnection.nodes": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes(childComplexity), true + + case "WorkloadVulnerabilitySummaryConnection.pageInfo": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo(childComplexity), true + + case "WorkloadVulnerabilitySummaryEdge.cursor": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor(childComplexity), true + + case "WorkloadVulnerabilitySummaryEdge.node": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node(childComplexity), true + + case "WorkloadWithVulnerability.vulnerability": + if e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability(childComplexity), true + + case "WorkloadWithVulnerability.workload": + if e.ComplexityRoot.WorkloadWithVulnerability.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerability.Workload(childComplexity), true + + case "WorkloadWithVulnerabilityConnection.edges": + if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges(childComplexity), true + + case "WorkloadWithVulnerabilityConnection.nodes": + if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes(childComplexity), true + + case "WorkloadWithVulnerabilityConnection.pageInfo": + if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo(childComplexity), true + + case "WorkloadWithVulnerabilityEdge.cursor": + if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor(childComplexity), true + + case "WorkloadWithVulnerabilityEdge.node": + if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node(childComplexity), true + + } + return 0, false +} + +func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { + opCtx := graphql.GetOperationContext(ctx) + ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult)) + inputUnmarshalMap := graphql.BuildUnmarshalerMap( + ec.unmarshalInputActivityLogFilter, + ec.unmarshalInputAddConfigValueInput, + ec.unmarshalInputAddRepositoryToTeamInput, + ec.unmarshalInputAddSecretValueInput, + ec.unmarshalInputAddTeamMemberInput, + ec.unmarshalInputAlertOrder, + ec.unmarshalInputAllowTeamAccessToUnleashInput, + ec.unmarshalInputApplicationOrder, + ec.unmarshalInputAssignRoleToServiceAccountInput, + ec.unmarshalInputBigQueryDatasetAccessOrder, + ec.unmarshalInputBigQueryDatasetOrder, + ec.unmarshalInputBucketOrder, + ec.unmarshalInputCVEOrder, + ec.unmarshalInputChangeDeploymentKeyInput, + ec.unmarshalInputConfigFilter, + ec.unmarshalInputConfigOrder, + ec.unmarshalInputConfigValueInput, + ec.unmarshalInputConfigureReconcilerInput, + ec.unmarshalInputConfirmTeamDeletionInput, + ec.unmarshalInputCreateConfigInput, + ec.unmarshalInputCreateKafkaCredentialsInput, + ec.unmarshalInputCreateOpenSearchCredentialsInput, + ec.unmarshalInputCreateOpenSearchInput, + ec.unmarshalInputCreateSecretInput, + ec.unmarshalInputCreateServiceAccountInput, + ec.unmarshalInputCreateServiceAccountTokenInput, + ec.unmarshalInputCreateTeamInput, + ec.unmarshalInputCreateUnleashForTeamInput, + ec.unmarshalInputCreateValkeyCredentialsInput, + ec.unmarshalInputCreateValkeyInput, + ec.unmarshalInputDeleteApplicationInput, + ec.unmarshalInputDeleteConfigInput, + ec.unmarshalInputDeleteJobInput, + ec.unmarshalInputDeleteOpenSearchInput, + ec.unmarshalInputDeleteSecretInput, + ec.unmarshalInputDeleteServiceAccountInput, + ec.unmarshalInputDeleteServiceAccountTokenInput, + ec.unmarshalInputDeleteUnleashInstanceInput, + ec.unmarshalInputDeleteValkeyInput, + ec.unmarshalInputDeploymentFilter, + ec.unmarshalInputDeploymentOrder, + ec.unmarshalInputDisableReconcilerInput, + ec.unmarshalInputEnableReconcilerInput, + ec.unmarshalInputEnvironmentOrder, + ec.unmarshalInputEnvironmentWorkloadOrder, + ec.unmarshalInputGrantPostgresAccessInput, + ec.unmarshalInputImageVulnerabilityFilter, + ec.unmarshalInputImageVulnerabilityOrder, + ec.unmarshalInputIngressMetricsInput, + ec.unmarshalInputIssueFilter, + ec.unmarshalInputIssueOrder, + ec.unmarshalInputJobOrder, + ec.unmarshalInputKafkaTopicAclFilter, + ec.unmarshalInputKafkaTopicAclOrder, + ec.unmarshalInputKafkaTopicOrder, + ec.unmarshalInputLogSubscriptionFilter, + ec.unmarshalInputLogSubscriptionInitialBatch, + ec.unmarshalInputMetricsQueryInput, + ec.unmarshalInputMetricsRangeInput, + ec.unmarshalInputOpenSearchAccessOrder, + ec.unmarshalInputOpenSearchOrder, + ec.unmarshalInputPostgresInstanceOrder, + ec.unmarshalInputReconcilerConfigInput, + ec.unmarshalInputRemoveConfigValueInput, + ec.unmarshalInputRemoveRepositoryFromTeamInput, + ec.unmarshalInputRemoveSecretValueInput, + ec.unmarshalInputRemoveTeamMemberInput, + ec.unmarshalInputRepositoryOrder, + ec.unmarshalInputRequestTeamDeletionInput, + ec.unmarshalInputResourceIssueFilter, + ec.unmarshalInputRestartApplicationInput, + ec.unmarshalInputRevokeRoleFromServiceAccountInput, + ec.unmarshalInputRevokeTeamAccessToUnleashInput, + ec.unmarshalInputSearchFilter, + ec.unmarshalInputSecretFilter, + ec.unmarshalInputSecretOrder, + ec.unmarshalInputSecretValueInput, + ec.unmarshalInputSetTeamMemberRoleInput, + ec.unmarshalInputSqlInstanceOrder, + ec.unmarshalInputSqlInstanceUserOrder, + ec.unmarshalInputStartOpenSearchMaintenanceInput, + ec.unmarshalInputStartValkeyMaintenanceInput, + ec.unmarshalInputTeamAlertsFilter, + ec.unmarshalInputTeamApplicationsFilter, + ec.unmarshalInputTeamCostDailyFilter, + ec.unmarshalInputTeamFilter, + ec.unmarshalInputTeamJobsFilter, + ec.unmarshalInputTeamMemberOrder, + ec.unmarshalInputTeamOrder, + ec.unmarshalInputTeamRepositoryFilter, + ec.unmarshalInputTeamVulnerabilitySummaryFilter, + ec.unmarshalInputTeamWorkloadsFilter, + ec.unmarshalInputTriggerJobInput, + ec.unmarshalInputUpdateConfigValueInput, + ec.unmarshalInputUpdateImageVulnerabilityInput, + ec.unmarshalInputUpdateOpenSearchInput, + ec.unmarshalInputUpdateSecretValueInput, + ec.unmarshalInputUpdateServiceAccountInput, + ec.unmarshalInputUpdateServiceAccountTokenInput, + ec.unmarshalInputUpdateTeamEnvironmentInput, + ec.unmarshalInputUpdateTeamInput, + ec.unmarshalInputUpdateUnleashInstanceInput, + ec.unmarshalInputUpdateValkeyInput, + ec.unmarshalInputUserOrder, + ec.unmarshalInputUserTeamOrder, + ec.unmarshalInputValkeyAccessOrder, + ec.unmarshalInputValkeyOrder, + ec.unmarshalInputViewSecretValuesInput, + ec.unmarshalInputVulnerabilitySummaryOrder, + ec.unmarshalInputWorkloadLogSubscriptionFilter, + ec.unmarshalInputWorkloadOrder, + ec.unmarshalInputWorkloadUtilizationSeriesInput, + ) + first := true + + switch opCtx.Operation.Operation { + case ast.Query: + return func(ctx context.Context) *graphql.Response { + var response graphql.Response + var data graphql.Marshaler + if first { + first = false + ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) + data = ec._Query(ctx, opCtx.Operation.SelectionSet) + } else { + if atomic.LoadInt32(&ec.PendingDeferred) > 0 { + result := <-ec.DeferredResults + atomic.AddInt32(&ec.PendingDeferred, -1) + data = result.Result + response.Path = result.Path + response.Label = result.Label + response.Errors = result.Errors + } else { + return nil + } + } + var buf bytes.Buffer + data.MarshalGQL(&buf) + response.Data = buf.Bytes() + if atomic.LoadInt32(&ec.Deferred) > 0 { + hasNext := atomic.LoadInt32(&ec.PendingDeferred) > 0 + response.HasNext = &hasNext + } + + return &response + } + case ast.Mutation: + return func(ctx context.Context) *graphql.Response { + if !first { + return nil + } + first = false + ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) + data := ec._Mutation(ctx, opCtx.Operation.SelectionSet) + var buf bytes.Buffer + data.MarshalGQL(&buf) + + return &graphql.Response{ + Data: buf.Bytes(), + } + } + case ast.Subscription: + next := ec._Subscription(ctx, opCtx.Operation.SelectionSet) + + var buf bytes.Buffer + return func(ctx context.Context) *graphql.Response { + buf.Reset() + data := next(ctx) + + if data == nil { + return nil + } + data.MarshalGQL(&buf) + + return &graphql.Response{ + Data: buf.Bytes(), + } + } + + default: + return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) + } +} + +type executionContext struct { + *graphql.ExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot] +} + +func newExecutionContext( + opCtx *graphql.OperationContext, + execSchema *executableSchema, + deferredResults chan graphql.DeferredResult, +) executionContext { + return executionContext{ + ExecutionContextState: graphql.NewExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot]( + opCtx, + (*graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot])(execSchema), + parsedSchema, + deferredResults, + ), + } +} + +var sources = []*ast.Source{ + {Name: "../schema/activitylog.graphqls", Input: `extend type Team implements ActivityLogger { + """ + Activity log associated with the team. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +interface ActivityLogger { + """ + Activity log associated with the type. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type Reconciler implements ActivityLogger { + """ + Activity log associated with the reconciler. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type OpenSearch implements ActivityLogger { + """ + Activity log associated with the reconciler. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type Valkey implements ActivityLogger { + """ + Activity log associated with the reconciler. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +input ActivityLogFilter { + activityTypes: [ActivityLogActivityType!] +} + +enum ActivityLogActivityType + +""" +Interface for activity log entries. +""" +interface ActivityLogEntry implements Node { + """ + ID of the entry. + """ + id: ID! + + """ + The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user. + """ + actor: String! + + """ + Creation time of the entry. + """ + createdAt: Time! + + """ + Message that summarizes the entry. + """ + message: String! + + """ + Type of the resource that was affected by the action. + """ + resourceType: ActivityLogEntryResourceType! + + """ + Name of the resource that was affected by the action. + """ + resourceName: String! + + """ + The team slug that the entry belongs to. + """ + teamSlug: Slug + + """ + The environment name that the entry belongs to. + """ + environmentName: String +} + +""" +The type of the resource that was affected by the activity. +""" +enum ActivityLogEntryResourceType { + """ + Unknown type. + """ + UNKNOWN +} + +""" +Activity log connection. +""" +type ActivityLogEntryConnection { + """ + Pagination information. + """ + pageInfo: PageInfo! + + """ + List of nodes. + """ + nodes: [ActivityLogEntry!]! + + """ + List of edges. + """ + edges: [ActivityLogEntryEdge!]! +} + +""" +Activity log edge. +""" +type ActivityLogEntryEdge { + """ + Cursor for this edge that can be used for pagination. + """ + cursor: Cursor! + + """ + The log entry. + """ + node: ActivityLogEntry! +} +`, BuiltIn: false}, + {Name: "../schema/aiven_credentials.graphqls", Input: `"Permission level for OpenSearch and Valkey credentials." +enum CredentialPermission { + READ + WRITE + READWRITE + ADMIN +} + +input CreateOpenSearchCredentialsInput { + "The team that owns the OpenSearch instance." + teamSlug: Slug! + "The environment name that the OpenSearch instance belongs to." + environmentName: String! + "Name of the OpenSearch instance." + instanceName: String! + "Permission level for the credentials." + permission: CredentialPermission! + "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." + ttl: String! +} - return &graphql.Response{ - Data: buf.Bytes(), - } - } +type OpenSearchCredentials { + "Username for the OpenSearch instance." + username: String! + "Password for the OpenSearch instance." + password: String! + "Hostname of the OpenSearch instance." + host: String! + "Port of the OpenSearch instance." + port: Int! + "Full connection URI for the OpenSearch instance." + uri: String! +} - default: - return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) - } +type CreateOpenSearchCredentialsPayload { + "The generated credentials." + credentials: OpenSearchCredentials! } -type executionContext struct { - *graphql.ExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot] +input CreateValkeyCredentialsInput { + "The team that owns the Valkey instance." + teamSlug: Slug! + "The environment name that the Valkey instance belongs to." + environmentName: String! + "Name of the Valkey instance." + instanceName: String! + "Permission level for the credentials." + permission: CredentialPermission! + "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." + ttl: String! } -func newExecutionContext( - opCtx *graphql.OperationContext, - execSchema *executableSchema, - deferredResults chan graphql.DeferredResult, -) executionContext { - return executionContext{ - ExecutionContextState: graphql.NewExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot]( - opCtx, - (*graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot])(execSchema), - parsedSchema, - deferredResults, - ), - } +type ValkeyCredentials { + "Username for the Valkey instance." + username: String! + "Password for the Valkey instance." + password: String! + "Hostname of the Valkey instance." + host: String! + "Port of the Valkey instance." + port: Int! + "Full connection URI for the Valkey instance." + uri: String! } -var sources = []*ast.Source{ - {Name: "../schema/activitylog.graphqls", Input: `extend type Team implements ActivityLogger { - """ - Activity log associated with the team. - """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int +type CreateValkeyCredentialsPayload { + "The generated credentials." + credentials: ValkeyCredentials! +} - """ - Get items after this cursor. - """ - after: Cursor +input CreateKafkaCredentialsInput { + "The team that owns the Kafka topic." + teamSlug: Slug! + "The environment name that the Kafka topic belongs to." + environmentName: String! + "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." + ttl: String! +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +type KafkaCredentials { + "Username for the Kafka broker." + username: String! + "Client certificate in PEM format." + accessCert: String! + "Client private key in PEM format." + accessKey: String! + "CA certificate in PEM format." + caCert: String! + "Comma-separated list of broker addresses." + brokers: String! + "Schema registry URL." + schemaRegistry: String! +} - """ - Get items before this cursor. - """ - before: Cursor +type CreateKafkaCredentialsPayload { + "The generated credentials." + credentials: KafkaCredentials! +} - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! +extend enum ActivityLogEntryResourceType { + "All activity log entries related to credential creation will use this resource type." + CREDENTIALS } -interface ActivityLogger { - """ - Activity log associated with the type. - """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int +type CredentialsActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - """ - Get items after this cursor. - """ - after: Cursor + "The identity of the actor who performed the action." + actor: String! - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int + "Creation time of the entry." + createdAt: Time! - """ - Get items before this cursor. - """ - before: Cursor + "Message that summarizes the entry." + message: String! - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! -} + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! -extend type Reconciler implements ActivityLogger { - """ - Activity log associated with the reconciler. - """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + "Name of the resource that was affected by the action." + resourceName: String! - """ - Get items after this cursor. - """ - after: Cursor + "The team slug that the entry belongs to." + teamSlug: Slug! - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int + "The environment name that the entry belongs to." + environmentName: String - """ - Get items before this cursor. - """ - before: Cursor + "Data associated with the credential creation." + data: CredentialsActivityLogEntryData! +} - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! +type CredentialsActivityLogEntryData { + "The service type (OPENSEARCH, VALKEY, KAFKA)." + serviceType: String! + "The instance name, if applicable." + instanceName: String + "The permission level, if applicable." + permission: String + "The TTL that was requested for the credentials." + ttl: String! } -extend type OpenSearch implements ActivityLogger { +extend enum ActivityLogActivityType { + "Filter for credential creation events." + CREDENTIALS_CREATE +} + +extend type Mutation { + "Create temporary credentials for an OpenSearch instance." + createOpenSearchCredentials( + input: CreateOpenSearchCredentialsInput! + ): CreateOpenSearchCredentialsPayload! + "Create temporary credentials for a Valkey instance." + createValkeyCredentials(input: CreateValkeyCredentialsInput!): CreateValkeyCredentialsPayload! + "Create temporary credentials for Kafka." + createKafkaCredentials(input: CreateKafkaCredentialsInput!): CreateKafkaCredentialsPayload! +} +`, BuiltIn: false}, + {Name: "../schema/alerts.graphqls", Input: `extend type TeamEnvironment { """ - Activity log associated with the reconciler. + EXPERIMENTAL: DO NOT USE """ - activityLog( + alerts( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -15908,17 +16852,22 @@ extend type OpenSearch implements ActivityLogger { before: Cursor """ - Filter items. + Ordering options for items returned from the connection. """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + orderBy: AlertOrder + + """ + Filter the returned objects + """ + filter: TeamAlertsFilter + ): AlertConnection! } -extend type Valkey implements ActivityLogger { +extend type Team { """ - Activity log associated with the reconciler. + EXPERIMENTAL: DO NOT USE """ - activityLog( + alerts( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -15940,77 +16889,128 @@ extend type Valkey implements ActivityLogger { before: Cursor """ - Filter items. + Ordering options for items returned from the connection. """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + orderBy: AlertOrder + + """ + Filter the returned objects + """ + filter: TeamAlertsFilter + ): AlertConnection! } -input ActivityLogFilter { - activityTypes: [ActivityLogActivityType!] +""" +Alert interface. +""" +interface Alert implements Node { + """ + The unique identifier of the alert. + """ + id: ID! + """ + The name of the alert. + """ + name: String! + """ + The team responsible for the alert. + """ + team: Team! + """ + The team environment associated with the alert. + """ + teamEnvironment: TeamEnvironment! + """ + The current state of the alert (e.g. FIRING, PENDING, INACTIVE). + """ + state: AlertState! + """ + The query or expression evaluated for the alert. + """ + query: String! + """ + The time in seconds the alert condition must be met before it activates. + """ + duration: Float! } -enum ActivityLogActivityType - """ -Interface for activity log entries. +PrometheusAlert type """ -interface ActivityLogEntry implements Node { +type PrometheusAlert implements Node & Alert { + "The unique identifier for the alert." + id: ID! + "The name of the alert." + name: String! """ - ID of the entry. + The team that owns the alert. """ - id: ID! + team: Team! + """ + The team environment for the alert. + """ + teamEnvironment: TeamEnvironment! + """ + The state of the alert. + """ + state: AlertState! """ - The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user. + The query for the alert. """ - actor: String! + query: String! + """ + The duration for the alert. + """ + duration: Float! """ - Creation time of the entry. + The prometheus rule group for the alert. """ - createdAt: Time! + ruleGroup: String! """ - Message that summarizes the entry. + The alarms of the alert available if state is firing. """ - message: String! + alarms: [PrometheusAlarm!]! +} +type PrometheusAlarm { """ - Type of the resource that was affected by the action. + The action to take when the alert fires. """ - resourceType: ActivityLogEntryResourceType! + action: String! """ - Name of the resource that was affected by the action. + The consequence of the alert firing. """ - resourceName: String! + consequence: String! """ - The team slug that the entry belongs to. + A summary of the alert. """ - teamSlug: Slug + summary: String! """ - The environment name that the entry belongs to. + The state of the alert. """ - environmentName: String -} + state: AlertState! -""" -The type of the resource that was affected by the activity. -""" -enum ActivityLogEntryResourceType { """ - Unknown type. + The current value of the metric that triggered the alert. """ - UNKNOWN + value: Float! + + """ + The time when the alert started firing. + """ + since: Time! } """ -Activity log connection. +AlertConnection connection. """ -type ActivityLogEntryConnection { +type AlertConnection { """ Pagination information. """ @@ -16019,194 +17019,245 @@ type ActivityLogEntryConnection { """ List of nodes. """ - nodes: [ActivityLogEntry!]! + nodes: [Alert!]! """ List of edges. """ - edges: [ActivityLogEntryEdge!]! + edges: [AlertEdge!]! } """ -Activity log edge. +Alert edge. """ -type ActivityLogEntryEdge { +type AlertEdge { """ Cursor for this edge that can be used for pagination. """ cursor: Cursor! """ - The log entry. + The Alert. """ - node: ActivityLogEntry! + node: Alert! } -`, BuiltIn: false}, - {Name: "../schema/aiven_credentials.graphqls", Input: `"Permission level for OpenSearch and Valkey credentials." -enum CredentialPermission { - READ - WRITE - READWRITE - ADMIN + +""" +Fields to order alerts in an environment by. +""" +enum AlertOrderField { + """ + Order by name. + """ + NAME + """ + Order by state. + """ + STATE + """ + ENVIRONMENT + """ + ENVIRONMENT } -input CreateOpenSearchCredentialsInput { - "The team that owns the OpenSearch instance." - teamSlug: Slug! - "The environment name that the OpenSearch instance belongs to." - environmentName: String! - "Name of the OpenSearch instance." - instanceName: String! - "Permission level for the credentials." - permission: CredentialPermission! - "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." - ttl: String! +""" +Ordering options when fetching alerts. +""" +input AlertOrder { + """ + The field to order items by. + """ + field: AlertOrderField! + + """ + The direction to order items by. + """ + direction: OrderDirection! } -type OpenSearchCredentials { - "Username for the OpenSearch instance." - username: String! - "Password for the OpenSearch instance." - password: String! - "Hostname of the OpenSearch instance." - host: String! - "Port of the OpenSearch instance." - port: Int! - "Full connection URI for the OpenSearch instance." - uri: String! +""" +Input for filtering alerts. +""" +input TeamAlertsFilter { + """ + Filter by the name of the application. + """ + name: String + """ + Filter by the name of the environment. + """ + environments: [String!] + """ + Only return alerts from the given named states. + """ + states: [AlertState!] } -type CreateOpenSearchCredentialsPayload { - "The generated credentials." - credentials: OpenSearchCredentials! +enum AlertState { + """ + Only return alerts that are firing. + """ + FIRING + + """ + Only return alerts that are inactive. + """ + INACTIVE + + """ + Only return alerts that are pending. + """ + PENDING } +`, BuiltIn: false}, + {Name: "../schema/applications.graphqls", Input: `extend type Team { + """ + Nais applications owned by the team. + """ + applications( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int -input CreateValkeyCredentialsInput { - "The team that owns the Valkey instance." - teamSlug: Slug! - "The environment name that the Valkey instance belongs to." - environmentName: String! - "Name of the Valkey instance." - instanceName: String! - "Permission level for the credentials." - permission: CredentialPermission! - "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." - ttl: String! + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Ordering options for items returned from the connection. + """ + orderBy: ApplicationOrder + + """ + Filtering options for items returned from the connection. + """ + filter: TeamApplicationsFilter + ): ApplicationConnection! } -type ValkeyCredentials { - "Username for the Valkey instance." - username: String! - "Password for the Valkey instance." - password: String! - "Hostname of the Valkey instance." - host: String! - "Port of the Valkey instance." - port: Int! - "Full connection URI for the Valkey instance." - uri: String! +extend type TeamEnvironment { + """ + Nais application in the team environment. + """ + application( + """ + The name of the application. + """ + name: String! + ): Application! } -type CreateValkeyCredentialsPayload { - "The generated credentials." - credentials: ValkeyCredentials! -} +extend type Mutation { + """ + Delete an application. + """ + deleteApplication( + """ + Input for deleting an application. + """ + input: DeleteApplicationInput! + ): DeleteApplicationPayload! -input CreateKafkaCredentialsInput { - "The team that owns the Kafka topic." - teamSlug: Slug! - "The environment name that the Kafka topic belongs to." - environmentName: String! - "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." - ttl: String! + """ + Restart an application. + """ + restartApplication( + """ + Input for restarting an application. + """ + input: RestartApplicationInput! + ): RestartApplicationPayload! } -type KafkaCredentials { - "Username for the Kafka broker." - username: String! - "Client certificate in PEM format." - accessCert: String! - "Client private key in PEM format." - accessKey: String! - "CA certificate in PEM format." - caCert: String! - "Comma-separated list of broker addresses." - brokers: String! - "Schema registry URL." - schemaRegistry: String! +extend type TeamInventoryCounts { + """ + Application inventory count for a team. + """ + applications: TeamInventoryCountApplications! } -type CreateKafkaCredentialsPayload { - "The generated credentials." - credentials: KafkaCredentials! +""" +Application inventory count for a team. +""" +type TeamInventoryCountApplications { + """ + Total number of applications. + """ + total: Int! } -extend enum ActivityLogEntryResourceType { - "All activity log entries related to credential creation will use this resource type." - CREDENTIALS -} +""" +An application lets you run one or more instances of a container image on the [Nais platform](https://nais.io/). -type CredentialsActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." +Learn more about how to create and configure your applications in the [Nais documentation](https://docs.nais.io/workloads/application/). +""" +type Application implements Node & Workload & ActivityLogger { + """ + The globally unique ID of the application. + """ id: ID! - "The identity of the actor who performed the action." - actor: String! - - "Creation time of the entry." - createdAt: Time! + """ + The name of the application. + """ + name: String! - "Message that summarizes the entry." - message: String! + """ + The team that owns the application. + """ + team: Team! - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! + """ + The environment the application is deployed in. + """ + environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") - "Name of the resource that was affected by the action." - resourceName: String! + """ + The team environment for the application. + """ + teamEnvironment: TeamEnvironment! - "The team slug that the entry belongs to." - teamSlug: Slug! + """ + The container image of the application. + """ + image: ContainerImage! - "The environment name that the entry belongs to." - environmentName: String + """ + Resources for the application. + """ + resources: ApplicationResources! - "Data associated with the credential creation." - data: CredentialsActivityLogEntryData! -} + """ + List of ingresses for the application. + """ + ingresses: [Ingress!]! -type CredentialsActivityLogEntryData { - "The service type (OPENSEARCH, VALKEY, KAFKA)." - serviceType: String! - "The instance name, if applicable." - instanceName: String - "The permission level, if applicable." - permission: String - "The TTL that was requested for the credentials." - ttl: String! -} + """ + List of authentication and authorization for the application. + """ + authIntegrations: [ApplicationAuthIntegrations!]! -extend enum ActivityLogActivityType { - "Filter for credential creation events." - CREDENTIALS_CREATE -} + """ + The application manifest. + """ + manifest: ApplicationManifest! -extend type Mutation { - "Create temporary credentials for an OpenSearch instance." - createOpenSearchCredentials( - input: CreateOpenSearchCredentialsInput! - ): CreateOpenSearchCredentialsPayload! - "Create temporary credentials for a Valkey instance." - createValkeyCredentials(input: CreateValkeyCredentialsInput!): CreateValkeyCredentialsPayload! - "Create temporary credentials for Kafka." - createKafkaCredentials(input: CreateKafkaCredentialsInput!): CreateKafkaCredentialsPayload! -} -`, BuiltIn: false}, - {Name: "../schema/alerts.graphqls", Input: `extend type TeamEnvironment { """ - EXPERIMENTAL: DO NOT USE + The application instances. """ - alerts( + instances( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -16226,24 +17277,17 @@ extend type Mutation { Get items before this cursor. """ before: Cursor + ): ApplicationInstanceConnection! - """ - Ordering options for items returned from the connection. - """ - orderBy: AlertOrder - - """ - Filter the returned objects - """ - filter: TeamAlertsFilter - ): AlertConnection! -} + """ + If set, when the application was marked for deletion. + """ + deletionStartedAt: Time -extend type Team { """ - EXPERIMENTAL: DO NOT USE + Activity log associated with the application. """ - alerts( + activityLog( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -16265,128 +17309,162 @@ extend type Team { before: Cursor """ - Ordering options for items returned from the connection. + Filter items. """ - orderBy: AlertOrder + filter: ActivityLogFilter + ): ActivityLogEntryConnection! - """ - Filter the returned objects - """ - filter: TeamAlertsFilter - ): AlertConnection! + "The application state." + state: ApplicationState! + + "Issues that affect the application." + issues( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: IssueOrder + + "Filtering options for items returned from the connection." + filter: ResourceIssueFilter + ): IssueConnection! } -""" -Alert interface. -""" -interface Alert implements Node { - """ - The unique identifier of the alert. - """ - id: ID! - """ - The name of the alert. - """ - name: String! - """ - The team responsible for the alert. - """ - team: Team! - """ - The team environment associated with the alert. - """ - teamEnvironment: TeamEnvironment! +enum ApplicationState { """ - The current state of the alert (e.g. FIRING, PENDING, INACTIVE). + The application is running. """ - state: AlertState! + RUNNING + """ - The query or expression evaluated for the alert. + The application is not running. """ - query: String! + NOT_RUNNING + """ - The time in seconds the alert condition must be met before it activates. + The application state is unknown. """ - duration: Float! + UNKNOWN } """ -PrometheusAlert type +Input for filtering the applications of a team. """ -type PrometheusAlert implements Node & Alert { - "The unique identifier for the alert." - id: ID! - "The name of the alert." - name: String! +input TeamApplicationsFilter { """ - The team that owns the alert. + Filter by the name of the application. """ - team: Team! + name: String + """ - The team environment for the alert. + Filter by the name of the environment. """ - teamEnvironment: TeamEnvironment! + environments: [String!] +} + +""" +The manifest that describes the application. +""" +type ApplicationManifest implements WorkloadManifest { """ - The state of the alert. + The manifest content, serialized as a YAML document. """ - state: AlertState! + content: String! +} + +""" +Authentication integrations for the application. +""" +union ApplicationAuthIntegrations = + | EntraIDAuthIntegration + | IDPortenAuthIntegration + | MaskinportenAuthIntegration + | TokenXAuthIntegration +type ApplicationResources implements WorkloadResources { """ - The query for the alert. + Instances using resources above this threshold will be killed. """ - query: String! + limits: WorkloadResourceQuantity! + """ - The duration for the alert. + How many resources are allocated to each instance. """ - duration: Float! + requests: WorkloadResourceQuantity! """ - The prometheus rule group for the alert. + Scaling strategies for the application. """ - ruleGroup: String! + scaling: ApplicationScaling! +} +""" +The scaling configuration of an application. +""" +type ApplicationScaling { """ - The alarms of the alert available if state is firing. + The minimum number of application instances. """ - alarms: [PrometheusAlarm!]! -} + minInstances: Int! -type PrometheusAlarm { """ - The action to take when the alert fires. + The maximum number of application instances. """ - action: String! + maxInstances: Int! """ - The consequence of the alert firing. + Scaling strategies for the application. """ - consequence: String! + strategies: [ScalingStrategy!]! +} + +""" +Types of scaling strategies. +""" +union ScalingStrategy = CPUScalingStrategy | KafkaLagScalingStrategy + +""" +A scaling strategy based on CPU usage +Read more: https://docs.nais.io/workloads/application/reference/automatic-scaling/#cpu-based-scaling +""" +type CPUScalingStrategy { """ - A summary of the alert. + The threshold that must be met for the scaling to trigger. """ - summary: String! + threshold: Int! +} +type KafkaLagScalingStrategy { """ - The state of the alert. + The threshold that must be met for the scaling to trigger. """ - state: AlertState! + threshold: Int! """ - The current value of the metric that triggered the alert. + The consumer group of the topic. """ - value: Float! + consumerGroup: String! """ - The time when the alert started firing. + The name of the Kafka topic. """ - since: Time! + topicName: String! } """ -AlertConnection connection. +Application connection. """ -type AlertConnection { +type ApplicationConnection { """ Pagination information. """ @@ -16395,55 +17473,37 @@ type AlertConnection { """ List of nodes. """ - nodes: [Alert!]! + nodes: [Application!]! """ List of edges. """ - edges: [AlertEdge!]! + edges: [ApplicationEdge!]! } """ -Alert edge. +Application edge. """ -type AlertEdge { +type ApplicationEdge { """ Cursor for this edge that can be used for pagination. """ cursor: Cursor! """ - The Alert. - """ - node: Alert! -} - -""" -Fields to order alerts in an environment by. -""" -enum AlertOrderField { - """ - Order by name. - """ - NAME - """ - Order by state. - """ - STATE - """ - ENVIRONMENT + The application. """ - ENVIRONMENT + node: Application! } """ -Ordering options when fetching alerts. +Ordering options when fetching applications. """ -input AlertOrder { +input ApplicationOrder { """ The field to order items by. """ - field: AlertOrderField! + field: ApplicationOrderField! """ The direction to order items by. @@ -16452,686 +17512,645 @@ input AlertOrder { } """ -Input for filtering alerts. +Fields to order applications by. """ -input TeamAlertsFilter { +enum ApplicationOrderField { """ - Filter by the name of the application. + Order applications by name. """ - name: String + NAME + """ - Filter by the name of the environment. + Order applications by the name of the environment. """ - environments: [String!] + ENVIRONMENT + """ - Only return alerts from the given named states. + Order applications by state. """ - states: [AlertState!] + STATE } -enum AlertState { +extend union SearchNode = Application + +extend enum SearchType { """ - Only return alerts that are firing. + Search for applications. """ - FIRING + APPLICATION +} +input DeleteApplicationInput { """ - Only return alerts that are inactive. + Name of the application. """ - INACTIVE + name: String! """ - Only return alerts that are pending. + Slug of the team that owns the application. """ - PENDING -} -`, BuiltIn: false}, - {Name: "../schema/applications.graphqls", Input: `extend type Team { + teamSlug: Slug! + """ - Nais applications owned by the team. + Name of the environment where the application runs. """ - applications( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int - - """ - Get items after this cursor. - """ - after: Cursor - - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int - - """ - Get items before this cursor. - """ - before: Cursor + environmentName: String! +} - """ - Ordering options for items returned from the connection. - """ - orderBy: ApplicationOrder +type DeleteApplicationPayload { + """ + The team that owned the deleted application. + """ + team: Team - """ - Filtering options for items returned from the connection. - """ - filter: TeamApplicationsFilter - ): ApplicationConnection! + """ + Whether or not the application was deleted. + """ + success: Boolean } -extend type TeamEnvironment { +input RestartApplicationInput { """ - Nais application in the team environment. + Name of the application. """ - application( - """ - The name of the application. - """ - name: String! - ): Application! + name: String! + + """ + Slug of the team that owns the application. + """ + teamSlug: Slug! + + """ + Name of the environment where the application runs. + """ + environmentName: String! } -extend type Mutation { +type RestartApplicationPayload { """ - Delete an application. + The application that was restarted. """ - deleteApplication( - """ - Input for deleting an application. - """ - input: DeleteApplicationInput! - ): DeleteApplicationPayload! + application: Application +} +type Ingress { """ - Restart an application. + URL for the ingress. """ - restartApplication( - """ - Input for restarting an application. - """ - input: RestartApplicationInput! - ): RestartApplicationPayload! -} + url: String! -extend type TeamInventoryCounts { """ - Application inventory count for a team. + Type of ingress. """ - applications: TeamInventoryCountApplications! -} + type: IngressType! -""" -Application inventory count for a team. -""" -type TeamInventoryCountApplications { """ - Total number of applications. + Metrics for the ingress. """ - total: Int! + metrics: IngressMetrics! } -""" -An application lets you run one or more instances of a container image on the [Nais platform](https://nais.io/). - -Learn more about how to create and configure your applications in the [Nais documentation](https://docs.nais.io/workloads/application/). -""" -type Application implements Node & Workload & ActivityLogger { +type IngressMetrics { """ - The globally unique ID of the application. + Number of requests to the ingress per second. """ - id: ID! + requestsPerSecond: Float! """ - The name of the application. + Number of errors in the ingress per second. """ - name: String! + errorsPerSecond: Float! + """ + Ingress metrics between start and end with step size. + """ + series(input: IngressMetricsInput!): [IngressMetricSample!]! +} +input IngressMetricsInput { """ - The team that owns the application. + Fetch metrics from this timestamp. """ - team: Team! + start: Time! """ - The environment the application is deployed in. + Fetch metrics until this timestamp. """ - environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") + end: Time! """ - The team environment for the application. + Type of metric to fetch. """ - teamEnvironment: TeamEnvironment! + type: IngressMetricsType! +} +""" +Type of ingress metrics to fetch. +""" +enum IngressMetricsType { """ - The container image of the application. + Number of requests to the ingress per second. + """ + REQUESTS_PER_SECOND + """ + Number of errors in the ingress per second. """ + ERRORS_PER_SECOND +} + +""" +Ingress metric type. +""" +type IngressMetricSample { + "Timestamp of the value." + timestamp: Time! + "Value of the IngressMetricsType at the given timestamp." + value: Float! +} + +enum IngressType { + UNKNOWN + EXTERNAL + INTERNAL + AUTHENTICATED +} + +type ApplicationInstance implements Node { + id: ID! + name: String! image: ContainerImage! + restarts: Int! + created: Time! + status: ApplicationInstanceStatus! +} + +type ApplicationInstanceStatus { + state: ApplicationInstanceState! + message: String! +} + +enum ApplicationInstanceState { + RUNNING + STARTING + FAILING + UNKNOWN +} +type ApplicationInstanceConnection { """ - Resources for the application. + Pagination information. """ - resources: ApplicationResources! + pageInfo: PageInfo! """ - List of ingresses for the application. + List of nodes. """ - ingresses: [Ingress!]! + nodes: [ApplicationInstance!]! """ - List of authentication and authorization for the application. + List of edges. """ - authIntegrations: [ApplicationAuthIntegrations!]! + edges: [ApplicationInstanceEdge!]! +} +type ApplicationInstanceEdge { """ - The application manifest. + Cursor for this edge that can be used for pagination. """ - manifest: ApplicationManifest! + cursor: Cursor! """ - The application instances. + The instance. """ - instances( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + node: ApplicationInstance! +} - """ - Get items after this cursor. - """ - after: Cursor +extend enum ActivityLogEntryResourceType { + "All activity log entries related to applications will use this resource type." + APP +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +type ApplicationDeletedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - """ - Get items before this cursor. - """ - before: Cursor - ): ApplicationInstanceConnection! + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! - """ - If set, when the application was marked for deletion. - """ - deletionStartedAt: Time + "Creation time of the entry." + createdAt: Time! - """ - Activity log associated with the application. - """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + "Message that summarizes the entry." + message: String! - """ - Get items after this cursor. - """ - after: Cursor + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int + "Name of the resource that was affected by the action." + resourceName: String! - """ - Get items before this cursor. - """ - before: Cursor + "The team slug that the entry belongs to." + teamSlug: Slug! - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + "The environment name that the entry belongs to." + environmentName: String +} - "The application state." - state: ApplicationState! +type ApplicationRestartedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - "Issues that affect the application." - issues( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! - "Get items after this cursor." - after: Cursor + "Creation time of the entry." + createdAt: Time! - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} + +# This is managed directly by the activitylog package since it +# combines data within the database. +type ApplicationScaledActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! - "Get items before this cursor." - before: Cursor + "Message that summarizes the entry." + message: String! - "Ordering options for items returned from the connection." - orderBy: IssueOrder + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! - "Filtering options for items returned from the connection." - filter: ResourceIssueFilter - ): IssueConnection! -} + "Name of the resource that was affected by the action." + resourceName: String! -enum ApplicationState { - """ - The application is running. - """ - RUNNING + "The team slug that the entry belongs to." + teamSlug: Slug! - """ - The application is not running. - """ - NOT_RUNNING + "The environment name that the entry belongs to." + environmentName: String - """ - The application state is unknown. - """ - UNKNOWN + "Data associated with the update." + data: ApplicationScaledActivityLogEntryData! } -""" -Input for filtering the applications of a team. -""" -input TeamApplicationsFilter { +enum ScalingDirection { """ - Filter by the name of the application. + The scaling direction is up. """ - name: String + UP """ - Filter by the name of the environment. + The scaling direction is down. """ - environments: [String!] + DOWN } -""" -The manifest that describes the application. -""" -type ApplicationManifest implements WorkloadManifest { - """ - The manifest content, serialized as a YAML document. - """ - content: String! +type ApplicationScaledActivityLogEntryData { + newSize: Int! + direction: ScalingDirection! } -""" -Authentication integrations for the application. -""" -union ApplicationAuthIntegrations = - | EntraIDAuthIntegration - | IDPortenAuthIntegration - | MaskinportenAuthIntegration - | TokenXAuthIntegration - -type ApplicationResources implements WorkloadResources { +extend enum ActivityLogActivityType { """ - Instances using resources above this threshold will be killed. + An application was deleted. """ - limits: WorkloadResourceQuantity! + APPLICATION_DELETED """ - How many resources are allocated to each instance. + An application was restarted. """ - requests: WorkloadResourceQuantity! + APPLICATION_RESTARTED """ - Scaling strategies for the application. + An application was scaled. """ - scaling: ApplicationScaling! + APPLICATION_SCALED } - -""" -The scaling configuration of an application. -""" -type ApplicationScaling { +`, BuiltIn: false}, + {Name: "../schema/authz.graphqls", Input: `type Role implements Node { """ - The minimum number of application instances. + The globally unique ID of the role. """ - minInstances: Int! + id: ID! """ - The maximum number of application instances. + Name of the role. """ - maxInstances: Int! + name: String! """ - Scaling strategies for the application. + Description of the role. """ - strategies: [ScalingStrategy!]! + description: String! } -""" -Types of scaling strategies. -""" -union ScalingStrategy = CPUScalingStrategy | KafkaLagScalingStrategy +extend type Query { + roles( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int -""" -A scaling strategy based on CPU usage + "Get items after this cursor." + after: Cursor -Read more: https://docs.nais.io/workloads/application/reference/automatic-scaling/#cpu-based-scaling -""" -type CPUScalingStrategy { - """ - The threshold that must be met for the scaling to trigger. - """ - threshold: Int! + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): RoleConnection! } -type KafkaLagScalingStrategy { +type RoleConnection { """ - The threshold that must be met for the scaling to trigger. + A list of roles. """ - threshold: Int! + nodes: [Role!]! """ - The consumer group of the topic. + A list of role edges. """ - consumerGroup: String! + edges: [RoleEdge!]! """ - The name of the Kafka topic. + Information to aid in pagination. """ - topicName: String! + pageInfo: PageInfo! } -""" -Application connection. -""" -type ApplicationConnection { +type RoleEdge { """ - Pagination information. + The role. """ - pageInfo: PageInfo! + node: Role! """ - List of nodes. + A cursor for use in pagination. """ - nodes: [Application!]! + cursor: Cursor! +} +`, BuiltIn: false}, + {Name: "../schema/bigquery.graphqls", Input: `extend type Team { + "BigQuery datasets owned by the team." + bigQueryDatasets( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - """ - List of edges. - """ - edges: [ApplicationEdge!]! + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! } -""" -Application edge. -""" -type ApplicationEdge { - """ - Cursor for this edge that can be used for pagination. - """ - cursor: Cursor! +extend type TeamEnvironment { + "BigQuery datasets in the team environment." + bigQueryDataset(name: String!): BigQueryDataset! +} - """ - The application. - """ - node: Application! +extend interface Workload { + "BigQuery datasets referenced by the workload. This does not currently support pagination, but will return all available datasets." + bigQueryDatasets( + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! } -""" -Ordering options when fetching applications. -""" -input ApplicationOrder { - """ - The field to order items by. - """ - field: ApplicationOrderField! +extend type Application { + "BigQuery datasets referenced by the application. This does not currently support pagination, but will return all available datasets." + bigQueryDatasets( + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! +} - """ - The direction to order items by. - """ - direction: OrderDirection! +extend type Job { + "BigQuery datasets referenced by the job. This does not currently support pagination, but will return all available datasets." + bigQueryDatasets( + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! } -""" -Fields to order applications by. -""" -enum ApplicationOrderField { - """ - Order applications by name. - """ - NAME +extend type TeamInventoryCounts { + bigQueryDatasets: TeamInventoryCountBigQueryDatasets! +} - """ - Order applications by the name of the environment. - """ - ENVIRONMENT +type TeamInventoryCountBigQueryDatasets { + "Total number of BigQuery datasets." + total: Int! +} - """ - Order applications by state. - """ - STATE +type BigQueryDataset implements Persistence & Node { + id: ID! + name: String! + team: Team! + environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") + teamEnvironment: TeamEnvironment! + cascadingDelete: Boolean! + description: String + access( + first: Int + after: Cursor + last: Int + before: Cursor + orderBy: BigQueryDatasetAccessOrder + ): BigQueryDatasetAccessConnection! + status: BigQueryDatasetStatus! + workload: Workload } -extend union SearchNode = Application - -extend enum SearchType { - """ - Search for applications. - """ - APPLICATION +type BigQueryDatasetAccess { + role: String! + email: String! } -input DeleteApplicationInput { - """ - Name of the application. - """ - name: String! - - """ - Slug of the team that owns the application. - """ - teamSlug: Slug! - - """ - Name of the environment where the application runs. - """ - environmentName: String! +type BigQueryDatasetStatus { + creationTime: Time! + lastModifiedTime: Time } -type DeleteApplicationPayload { - """ - The team that owned the deleted application. - """ - team: Team - - """ - Whether or not the application was deleted. - """ - success: Boolean +type BigQueryDatasetAccessConnection { + pageInfo: PageInfo! + nodes: [BigQueryDatasetAccess!]! + edges: [BigQueryDatasetAccessEdge!]! } -input RestartApplicationInput { - """ - Name of the application. - """ - name: String! +type BigQueryDatasetConnection { + pageInfo: PageInfo! + nodes: [BigQueryDataset!]! + edges: [BigQueryDatasetEdge!]! +} - """ - Slug of the team that owns the application. - """ - teamSlug: Slug! +type BigQueryDatasetAccessEdge { + cursor: Cursor! + node: BigQueryDatasetAccess! +} - """ - Name of the environment where the application runs. - """ - environmentName: String! +type BigQueryDatasetEdge { + cursor: Cursor! + node: BigQueryDataset! } -type RestartApplicationPayload { - """ - The application that was restarted. - """ - application: Application +input BigQueryDatasetAccessOrder { + field: BigQueryDatasetAccessOrderField! + direction: OrderDirection! } -type Ingress { - """ - URL for the ingress. - """ - url: String! +input BigQueryDatasetOrder { + field: BigQueryDatasetOrderField! + direction: OrderDirection! +} - """ - Type of ingress. - """ - type: IngressType! +enum BigQueryDatasetAccessOrderField { + ROLE + EMAIL +} - """ - Metrics for the ingress. - """ - metrics: IngressMetrics! +enum BigQueryDatasetOrderField { + NAME + ENVIRONMENT } -type IngressMetrics { - """ - Number of requests to the ingress per second. - """ - requestsPerSecond: Float! +extend union SearchNode = BigQueryDataset - """ - Number of errors in the ingress per second. - """ - errorsPerSecond: Float! - """ - Ingress metrics between start and end with step size. - """ - series(input: IngressMetricsInput!): [IngressMetricSample!]! +extend enum SearchType { + BIGQUERY_DATASET } +`, BuiltIn: false}, + {Name: "../schema/bucket.graphqls", Input: `extend type Team { + "Google Cloud Storage buckets owned by the team." + buckets( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int -input IngressMetricsInput { - """ - Fetch metrics from this timestamp. - """ - start: Time! + "Get items after this cursor." + after: Cursor - """ - Fetch metrics until this timestamp. - """ - end: Time! + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int - """ - Type of metric to fetch. - """ - type: IngressMetricsType! -} + "Get items before this cursor." + before: Cursor -""" -Type of ingress metrics to fetch. -""" -enum IngressMetricsType { - """ - Number of requests to the ingress per second. - """ - REQUESTS_PER_SECOND - """ - Number of errors in the ingress per second. - """ - ERRORS_PER_SECOND + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! } -""" -Ingress metric type. -""" -type IngressMetricSample { - "Timestamp of the value." - timestamp: Time! - "Value of the IngressMetricsType at the given timestamp." - value: Float! +extend type TeamEnvironment { + "Storage bucket in the team environment." + bucket(name: String!): Bucket! } -enum IngressType { - UNKNOWN - EXTERNAL - INTERNAL - AUTHENTICATED +extend interface Workload { + "Google Cloud Storage referenced by the workload. This does not currently support pagination, but will return all available buckets." + buckets( + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! } -type ApplicationInstance implements Node { - id: ID! - name: String! - image: ContainerImage! - restarts: Int! - created: Time! - status: ApplicationInstanceStatus! +extend type Application { + "Google Cloud Storage referenced by the application. This does not currently support pagination, but will return all available buckets." + buckets( + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! } -type ApplicationInstanceStatus { - state: ApplicationInstanceState! - message: String! +extend type Job { + "Google Cloud Storage referenced by the job. This does not currently support pagination, but will return all available buckets." + buckets( + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! } -enum ApplicationInstanceState { - RUNNING - STARTING - FAILING - UNKNOWN +extend type TeamInventoryCounts { + buckets: TeamInventoryCountBuckets! } -type ApplicationInstanceConnection { - """ - Pagination information. - """ - pageInfo: PageInfo! - - """ - List of nodes. - """ - nodes: [ApplicationInstance!]! - - """ - List of edges. - """ - edges: [ApplicationInstanceEdge!]! +type TeamInventoryCountBuckets { + "Total number of Google Cloud Storage buckets." + total: Int! } -type ApplicationInstanceEdge { - """ - Cursor for this edge that can be used for pagination. - """ - cursor: Cursor! +type Bucket implements Persistence & Node { + id: ID! + name: String! + team: Team! + environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") + teamEnvironment: TeamEnvironment! + cascadingDelete: Boolean! + publicAccessPrevention: String! + uniformBucketLevelAccess: Boolean! + workload: Workload +} - """ - The instance. - """ - node: ApplicationInstance! +type BucketConnection { + pageInfo: PageInfo! + nodes: [Bucket!]! + edges: [BucketEdge!]! } -extend enum ActivityLogEntryResourceType { - "All activity log entries related to applications will use this resource type." - APP +type BucketEdge { + cursor: Cursor! + node: Bucket! } -type ApplicationDeletedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! +input BucketOrder { + field: BucketOrderField! + direction: OrderDirection! +} - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! +enum BucketOrderField { + NAME + ENVIRONMENT +} - "Name of the resource that was affected by the action." - resourceName: String! +extend union SearchNode = Bucket - "The team slug that the entry belongs to." - teamSlug: Slug! +extend enum SearchType { + BUCKET +} +`, BuiltIn: false}, + {Name: "../schema/cluster.graphqls", Input: `extend enum ActivityLogEntryResourceType { + "All activity log entries related to direct cluster changes." + CLUSTER_AUDIT +} - "The environment name that the entry belongs to." - environmentName: String +extend enum ActivityLogActivityType { + "All activity log entries related to direct cluster changes." + CLUSTER_AUDIT } -type ApplicationRestartedActivityLogEntry implements ActivityLogEntry & Node { +type ClusterAuditActivityLogEntry implements ActivityLogEntry & Node { "ID of the entry." id: ID! @@ -17155,92 +18174,115 @@ type ApplicationRestartedActivityLogEntry implements ActivityLogEntry & Node { "The environment name that the entry belongs to." environmentName: String + + "Data associated with the entry." + data: ClusterAuditActivityLogEntryData! } -# This is managed directly by the activitylog package since it -# combines data within the database. -type ApplicationScaledActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! +type ClusterAuditActivityLogEntryData { + "The action that was performed." + action: String! + "The kind of resource that was affected by the action." + resourceKind: String! +} +`, BuiltIn: false}, + {Name: "../schema/configmap.graphqls", Input: `extend type Mutation { + "Create a new config." + createConfig(input: CreateConfigInput!): CreateConfigPayload! - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! + "Add a value to a config." + addConfigValue(input: AddConfigValueInput!): AddConfigValuePayload! - "Creation time of the entry." - createdAt: Time! + "Update a value within a config." + updateConfigValue(input: UpdateConfigValueInput!): UpdateConfigValuePayload! - "Message that summarizes the entry." - message: String! + "Remove a value from a config." + removeConfigValue(input: RemoveConfigValueInput!): RemoveConfigValuePayload! - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! + "Delete a config, and the values it contains." + deleteConfig(input: DeleteConfigInput!): DeleteConfigPayload! +} - "Name of the resource that was affected by the action." - resourceName: String! +extend type Team { + "Configs owned by the team." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - "The team slug that the entry belongs to." - teamSlug: Slug! + "Get items after this cursor." + after: Cursor - "The environment name that the entry belongs to." - environmentName: String + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int - "Data associated with the update." - data: ApplicationScaledActivityLogEntryData! + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: ConfigOrder + + "Filtering options for items returned from the connection." + filter: ConfigFilter + ): ConfigConnection! } -enum ScalingDirection { +""" +Input for filtering the configs of a team. +""" +input ConfigFilter { """ - The scaling direction is up. + Filter by the name of the config. """ - UP + name: String """ - The scaling direction is down. + Filter by usage of the config. """ - DOWN + inUse: Boolean } -type ApplicationScaledActivityLogEntryData { - newSize: Int! - direction: ScalingDirection! +extend type TeamEnvironment { + "Get a config by name." + config(name: String!): Config! } -extend enum ActivityLogActivityType { - """ - An application was deleted. - """ - APPLICATION_DELETED +extend interface Workload { + "Configs used by the workload." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - """ - An application was restarted. - """ - APPLICATION_RESTARTED + "Get items after this cursor." + after: Cursor - """ - An application was scaled. - """ - APPLICATION_SCALED + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ConfigConnection! } -`, BuiltIn: false}, - {Name: "../schema/authz.graphqls", Input: `type Role implements Node { - """ - The globally unique ID of the role. - """ - id: ID! - """ - Name of the role. - """ - name: String! +extend type Application { + "Configs used by the application." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - """ - Description of the role. - """ - description: String! + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ConfigConnection! } -extend type Query { - roles( +extend type Job { + "Configs used by the job." + configs( "Get the first n items in the connection. This can be used in combination with the after parameter." first: Int @@ -17252,41 +18294,28 @@ extend type Query { "Get items before this cursor." before: Cursor - ): RoleConnection! + ): ConfigConnection! } -type RoleConnection { - """ - A list of roles. - """ - nodes: [Role!]! +"A config is a collection of key-value pairs." +type Config implements Node & ActivityLogger { + "The globally unique ID of the config." + id: ID! - """ - A list of role edges. - """ - edges: [RoleEdge!]! + "The name of the config." + name: String! - """ - Information to aid in pagination. - """ - pageInfo: PageInfo! -} + "The environment the config exists in." + teamEnvironment: TeamEnvironment! -type RoleEdge { - """ - The role. - """ - node: Role! + "The team that owns the config." + team: Team! - """ - A cursor for use in pagination. - """ - cursor: Cursor! -} -`, BuiltIn: false}, - {Name: "../schema/bigquery.graphqls", Input: `extend type Team { - "BigQuery datasets owned by the team." - bigQueryDatasets( + "The values stored in the config." + values: [ConfigValue!]! + + "Applications that use the config." + applications( "Get the first n items in the connection. This can be used in combination with the after parameter." first: Int @@ -17298,235 +18327,255 @@ type RoleEdge { "Get items before this cursor." before: Cursor + ): ApplicationConnection! - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! -} + "Jobs that use the config." + jobs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int -extend type TeamEnvironment { - "BigQuery datasets in the team environment." - bigQueryDataset(name: String!): BigQueryDataset! -} + "Get items after this cursor." + after: Cursor -extend interface Workload { - "BigQuery datasets referenced by the workload. This does not currently support pagination, but will return all available datasets." - bigQueryDatasets( - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! -} + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int -extend type Application { - "BigQuery datasets referenced by the application. This does not currently support pagination, but will return all available datasets." - bigQueryDatasets( - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! -} + "Get items before this cursor." + before: Cursor + ): JobConnection! + + "Workloads that use the config." + workloads( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): WorkloadConnection! + + "Last time the config was modified." + lastModifiedAt: Time + + "User who last modified the config." + lastModifiedBy: User + + "Activity log associated with the config." + activityLog( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor -extend type Job { - "BigQuery datasets referenced by the job. This does not currently support pagination, but will return all available datasets." - bigQueryDatasets( - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! + "Filter items." + filter: ActivityLogFilter + ): ActivityLogEntryConnection! } extend type TeamInventoryCounts { - bigQueryDatasets: TeamInventoryCountBigQueryDatasets! + """ + Config inventory count for a team. + """ + configs: TeamInventoryCountConfigs! } -type TeamInventoryCountBigQueryDatasets { - "Total number of BigQuery datasets." +""" +Config inventory count for a team. +""" +type TeamInventoryCountConfigs { + """ + Total number of configs. + """ total: Int! } -type BigQueryDataset implements Persistence & Node { - id: ID! +input ConfigValueInput { + "The name of the config value." name: String! - team: Team! - environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") - teamEnvironment: TeamEnvironment! - cascadingDelete: Boolean! - description: String - access( - first: Int - after: Cursor - last: Int - before: Cursor - orderBy: BigQueryDatasetAccessOrder - ): BigQueryDatasetAccessConnection! - status: BigQueryDatasetStatus! - workload: Workload -} -type BigQueryDatasetAccess { - role: String! - email: String! + "The value to set." + value: String! } -type BigQueryDatasetStatus { - creationTime: Time! - lastModifiedTime: Time -} +input CreateConfigInput { + "The name of the config." + name: String! -type BigQueryDatasetAccessConnection { - pageInfo: PageInfo! - nodes: [BigQueryDatasetAccess!]! - edges: [BigQueryDatasetAccessEdge!]! -} + "The environment the config exists in." + environmentName: String! -type BigQueryDatasetConnection { - pageInfo: PageInfo! - nodes: [BigQueryDataset!]! - edges: [BigQueryDatasetEdge!]! + "The team that owns the config." + teamSlug: Slug! } -type BigQueryDatasetAccessEdge { - cursor: Cursor! - node: BigQueryDatasetAccess! -} +input AddConfigValueInput { + "The name of the config." + name: String! -type BigQueryDatasetEdge { - cursor: Cursor! - node: BigQueryDataset! -} + "The environment the config exists in." + environmentName: String! -input BigQueryDatasetAccessOrder { - field: BigQueryDatasetAccessOrderField! - direction: OrderDirection! -} + "The team that owns the config." + teamSlug: Slug! -input BigQueryDatasetOrder { - field: BigQueryDatasetOrderField! - direction: OrderDirection! + "The config value to add." + value: ConfigValueInput! } -enum BigQueryDatasetAccessOrderField { - ROLE - EMAIL -} +input UpdateConfigValueInput { + "The name of the config." + name: String! -enum BigQueryDatasetOrderField { - NAME - ENVIRONMENT -} + "The environment the config exists in." + environmentName: String! -extend union SearchNode = BigQueryDataset + "The team that owns the config." + teamSlug: Slug! -extend enum SearchType { - BIGQUERY_DATASET + "The config value to update." + value: ConfigValueInput! } -`, BuiltIn: false}, - {Name: "../schema/bucket.graphqls", Input: `extend type Team { - "Google Cloud Storage buckets owned by the team." - buckets( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - "Get items after this cursor." - after: Cursor +input RemoveConfigValueInput { + "The name of the config." + configName: String! - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int + "The environment the config exists in." + environmentName: String! - "Get items before this cursor." - before: Cursor + "The team that owns the config." + teamSlug: Slug! - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! + "The config value to remove." + valueName: String! } -extend type TeamEnvironment { - "Storage bucket in the team environment." - bucket(name: String!): Bucket! +input DeleteConfigInput { + "The name of the config." + name: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! } -extend interface Workload { - "Google Cloud Storage referenced by the workload. This does not currently support pagination, but will return all available buckets." - buckets( - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! +type CreateConfigPayload { + "The created config." + config: Config } -extend type Application { - "Google Cloud Storage referenced by the application. This does not currently support pagination, but will return all available buckets." - buckets( - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! +input ConfigOrder { + "The field to order items by." + field: ConfigOrderField! + + "The direction to order items by." + direction: OrderDirection! } -extend type Job { - "Google Cloud Storage referenced by the job. This does not currently support pagination, but will return all available buckets." - buckets( - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! +enum ConfigOrderField { + "Order configs by name." + NAME + + "Order configs by the name of the environment." + ENVIRONMENT + + "Order configs by the last time it was modified." + LAST_MODIFIED_AT } -extend type TeamInventoryCounts { - buckets: TeamInventoryCountBuckets! +type AddConfigValuePayload { + "The updated config." + config: Config } -type TeamInventoryCountBuckets { - "Total number of Google Cloud Storage buckets." - total: Int! +type UpdateConfigValuePayload { + "The updated config." + config: Config } -type Bucket implements Persistence & Node { - id: ID! - name: String! - team: Team! - environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") - teamEnvironment: TeamEnvironment! - cascadingDelete: Boolean! - publicAccessPrevention: String! - uniformBucketLevelAccess: Boolean! - workload: Workload +type RemoveConfigValuePayload { + "The updated config." + config: Config } -type BucketConnection { +type DeleteConfigPayload { + "The deleted config." + configDeleted: Boolean +} + +type ConfigConnection { + "Pagination information." pageInfo: PageInfo! - nodes: [Bucket!]! - edges: [BucketEdge!]! + + "List of nodes." + nodes: [Config!]! + + "List of edges." + edges: [ConfigEdge!]! } -type BucketEdge { +type ConfigEdge { + "Cursor for this edge that can be used for pagination." cursor: Cursor! - node: Bucket! + + "The Config." + node: Config! } -input BucketOrder { - field: BucketOrderField! - direction: OrderDirection! +type ConfigValue { + "The name of the config value." + name: String! + + "The config value itself." + value: String! } -enum BucketOrderField { - NAME - ENVIRONMENT +extend enum ActivityLogEntryResourceType { + "All activity log entries related to configs will use this resource type." + CONFIG } -extend union SearchNode = Bucket +type ConfigCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! -extend enum SearchType { - BUCKET -} -`, BuiltIn: false}, - {Name: "../schema/cluster.graphqls", Input: `extend enum ActivityLogEntryResourceType { - "All activity log entries related to direct cluster changes." - CLUSTER_AUDIT -} + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! -extend enum ActivityLogActivityType { - "All activity log entries related to direct cluster changes." - CLUSTER_AUDIT + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String } -type ClusterAuditActivityLogEntry implements ActivityLogEntry & Node { +type ConfigUpdatedActivityLogEntry implements ActivityLogEntry & Node { "ID of the entry." id: ID! @@ -17552,14 +18601,58 @@ type ClusterAuditActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the entry." - data: ClusterAuditActivityLogEntryData! + data: ConfigUpdatedActivityLogEntryData! } -type ClusterAuditActivityLogEntryData { - "The action that was performed." - action: String! - "The kind of resource that was affected by the action." - resourceKind: String! +type ConfigUpdatedActivityLogEntryDataUpdatedField { + "The name of the field that was updated." + field: String! + + "The old value of the field." + oldValue: String + + "The new value of the field." + newValue: String +} + +type ConfigUpdatedActivityLogEntryData { + "The fields that were updated." + updatedFields: [ConfigUpdatedActivityLogEntryDataUpdatedField!]! +} + +type ConfigDeletedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} + +extend enum ActivityLogActivityType { + "Config was created." + CONFIG_CREATED + "Config was updated." + CONFIG_UPDATED + "Config was deleted." + CONFIG_DELETED } `, BuiltIn: false}, {Name: "../schema/cost.graphqls", Input: `extend type Team { diff --git a/internal/graph/gengql/schema.generated.go b/internal/graph/gengql/schema.generated.go index 7b30fb15c..6752d8b08 100644 --- a/internal/graph/gengql/schema.generated.go +++ b/internal/graph/gengql/schema.generated.go @@ -50,6 +50,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/logging" "github.com/nais/api/internal/workload/podlog" @@ -65,6 +66,11 @@ type MutationResolver interface { CreateKafkaCredentials(ctx context.Context, input aivencredentials.CreateKafkaCredentialsInput) (*aivencredentials.CreateKafkaCredentialsPayload, error) DeleteApplication(ctx context.Context, input application.DeleteApplicationInput) (*application.DeleteApplicationPayload, error) RestartApplication(ctx context.Context, input application.RestartApplicationInput) (*application.RestartApplicationPayload, error) + CreateConfig(ctx context.Context, input configmap.CreateConfigInput) (*configmap.CreateConfigPayload, error) + AddConfigValue(ctx context.Context, input configmap.AddConfigValueInput) (*configmap.AddConfigValuePayload, error) + UpdateConfigValue(ctx context.Context, input configmap.UpdateConfigValueInput) (*configmap.UpdateConfigValuePayload, error) + RemoveConfigValue(ctx context.Context, input configmap.RemoveConfigValueInput) (*configmap.RemoveConfigValuePayload, error) + DeleteConfig(ctx context.Context, input configmap.DeleteConfigInput) (*configmap.DeleteConfigPayload, error) ChangeDeploymentKey(ctx context.Context, input deployment.ChangeDeploymentKeyInput) (*deployment.ChangeDeploymentKeyPayload, error) DeleteJob(ctx context.Context, input job.DeleteJobInput) (*job.DeleteJobPayload, error) TriggerJob(ctx context.Context, input job.TriggerJobInput) (*job.TriggerJobPayload, error) @@ -147,6 +153,17 @@ type SubscriptionResolver interface { // region ***************************** args.gotpl ***************************** +func (ec *executionContext) field_Mutation_addConfigValue_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNAddConfigValueInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐAddConfigValueInput) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} + func (ec *executionContext) field_Mutation_addRepositoryToTeam_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -235,6 +252,17 @@ func (ec *executionContext) field_Mutation_confirmTeamDeletion_args(ctx context. return args, nil } +func (ec *executionContext) field_Mutation_createConfig_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNCreateConfigInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐCreateConfigInput) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} + func (ec *executionContext) field_Mutation_createKafkaCredentials_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -356,6 +384,17 @@ func (ec *executionContext) field_Mutation_deleteApplication_args(ctx context.Co return args, nil } +func (ec *executionContext) field_Mutation_deleteConfig_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNDeleteConfigInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐDeleteConfigInput) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} + func (ec *executionContext) field_Mutation_deleteJob_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -466,6 +505,17 @@ func (ec *executionContext) field_Mutation_grantPostgresAccess_args(ctx context. return args, nil } +func (ec *executionContext) field_Mutation_removeConfigValue_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNRemoveConfigValueInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐRemoveConfigValueInput) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} + func (ec *executionContext) field_Mutation_removeRepositoryFromTeam_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -587,6 +637,17 @@ func (ec *executionContext) field_Mutation_triggerJob_args(ctx context.Context, return args, nil } +func (ec *executionContext) field_Mutation_updateConfigValue_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "input", ec.unmarshalNUpdateConfigValueInput2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐUpdateConfigValueInput) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} + func (ec *executionContext) field_Mutation_updateImageVulnerability_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -1360,6 +1421,231 @@ func (ec *executionContext) fieldContext_Mutation_restartApplication(ctx context return fc, nil } +func (ec *executionContext) _Mutation_createConfig(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Mutation_createConfig, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Mutation().CreateConfig(ctx, fc.Args["input"].(configmap.CreateConfigInput)) + }, + nil, + ec.marshalNCreateConfigPayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐCreateConfigPayload, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Mutation_createConfig(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "config": + return ec.fieldContext_CreateConfigPayload_config(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type CreateConfigPayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_createConfig_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_addConfigValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Mutation_addConfigValue, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Mutation().AddConfigValue(ctx, fc.Args["input"].(configmap.AddConfigValueInput)) + }, + nil, + ec.marshalNAddConfigValuePayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐAddConfigValuePayload, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Mutation_addConfigValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "config": + return ec.fieldContext_AddConfigValuePayload_config(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type AddConfigValuePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_addConfigValue_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_updateConfigValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Mutation_updateConfigValue, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Mutation().UpdateConfigValue(ctx, fc.Args["input"].(configmap.UpdateConfigValueInput)) + }, + nil, + ec.marshalNUpdateConfigValuePayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐUpdateConfigValuePayload, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Mutation_updateConfigValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "config": + return ec.fieldContext_UpdateConfigValuePayload_config(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type UpdateConfigValuePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_updateConfigValue_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_removeConfigValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Mutation_removeConfigValue, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Mutation().RemoveConfigValue(ctx, fc.Args["input"].(configmap.RemoveConfigValueInput)) + }, + nil, + ec.marshalNRemoveConfigValuePayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐRemoveConfigValuePayload, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Mutation_removeConfigValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "config": + return ec.fieldContext_RemoveConfigValuePayload_config(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type RemoveConfigValuePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_removeConfigValue_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_deleteConfig(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Mutation_deleteConfig, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Mutation().DeleteConfig(ctx, fc.Args["input"].(configmap.DeleteConfigInput)) + }, + nil, + ec.marshalNDeleteConfigPayload2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐDeleteConfigPayload, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Mutation_deleteConfig(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "configDeleted": + return ec.fieldContext_DeleteConfigPayload_configDeleted(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DeleteConfigPayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_deleteConfig_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Mutation_changeDeploymentKey(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -4334,6 +4620,8 @@ func (ec *executionContext) fieldContext_Query_team(ctx context.Context, field g return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -5689,6 +5977,34 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._ContainerImage(ctx, sel, obj) + case configmap.ConfigUpdatedActivityLogEntry: + return ec._ConfigUpdatedActivityLogEntry(ctx, sel, &obj) + case *configmap.ConfigUpdatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ConfigUpdatedActivityLogEntry(ctx, sel, obj) + case configmap.ConfigDeletedActivityLogEntry: + return ec._ConfigDeletedActivityLogEntry(ctx, sel, &obj) + case *configmap.ConfigDeletedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ConfigDeletedActivityLogEntry(ctx, sel, obj) + case configmap.ConfigCreatedActivityLogEntry: + return ec._ConfigCreatedActivityLogEntry(ctx, sel, &obj) + case *configmap.ConfigCreatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ConfigCreatedActivityLogEntry(ctx, sel, obj) + case configmap.Config: + return ec._Config(ctx, sel, &obj) + case *configmap.Config: + if obj == nil { + return graphql.Null + } + return ec._Config(ctx, sel, obj) case pubsublog.ClusterAuditActivityLogEntry: return ec._ClusterAuditActivityLogEntry(ctx, sel, &obj) case *pubsublog.ClusterAuditActivityLogEntry: @@ -5994,6 +6310,41 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) if out.Values[i] == graphql.Null { out.Invalids++ } + case "createConfig": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_createConfig(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "addConfigValue": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_addConfigValue(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "updateConfigValue": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_updateConfigValue(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "removeConfigValue": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_removeConfigValue(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "deleteConfig": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_deleteConfig(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } case "changeDeploymentKey": out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { return ec._Mutation_changeDeploymentKey(ctx, field) diff --git a/internal/graph/gengql/secret.generated.go b/internal/graph/gengql/secret.generated.go index 64023734f..0755d7cae 100644 --- a/internal/graph/gengql/secret.generated.go +++ b/internal/graph/gengql/secret.generated.go @@ -451,6 +451,8 @@ func (ec *executionContext) fieldContext_Secret_environment(_ context.Context, f return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -520,6 +522,8 @@ func (ec *executionContext) fieldContext_Secret_teamEnvironment(_ context.Contex return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -611,6 +615,8 @@ func (ec *executionContext) fieldContext_Secret_team(_ context.Context, field gr return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": diff --git a/internal/graph/gengql/serviceaccounts.generated.go b/internal/graph/gengql/serviceaccounts.generated.go index 1a3f15a09..18631842b 100644 --- a/internal/graph/gengql/serviceaccounts.generated.go +++ b/internal/graph/gengql/serviceaccounts.generated.go @@ -1294,6 +1294,8 @@ func (ec *executionContext) fieldContext_ServiceAccount_team(_ context.Context, return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": diff --git a/internal/graph/gengql/sqlinstance.generated.go b/internal/graph/gengql/sqlinstance.generated.go index 55d4a0bbf..084445a43 100644 --- a/internal/graph/gengql/sqlinstance.generated.go +++ b/internal/graph/gengql/sqlinstance.generated.go @@ -308,6 +308,8 @@ func (ec *executionContext) fieldContext_SqlDatabase_team(_ context.Context, fie return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -397,6 +399,8 @@ func (ec *executionContext) fieldContext_SqlDatabase_environment(_ context.Conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -466,6 +470,8 @@ func (ec *executionContext) fieldContext_SqlDatabase_teamEnvironment(_ context.C return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -731,6 +737,8 @@ func (ec *executionContext) fieldContext_SqlInstance_team(_ context.Context, fie return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -820,6 +828,8 @@ func (ec *executionContext) fieldContext_SqlInstance_environment(_ context.Conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -889,6 +899,8 @@ func (ec *executionContext) fieldContext_SqlInstance_teamEnvironment(_ context.C return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/teams.generated.go b/internal/graph/gengql/teams.generated.go index 235027ba8..fab2f17bb 100644 --- a/internal/graph/gengql/teams.generated.go +++ b/internal/graph/gengql/teams.generated.go @@ -33,6 +33,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/secret" "github.com/vektah/gqlparser/v2/ast" @@ -59,6 +60,7 @@ type TeamResolver interface { Applications(ctx context.Context, obj *team.Team, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *application.ApplicationOrder, filter *application.TeamApplicationsFilter) (*pagination.Connection[*application.Application], error) BigQueryDatasets(ctx context.Context, obj *team.Team, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bigquery.BigQueryDatasetOrder) (*pagination.Connection[*bigquery.BigQueryDataset], error) Buckets(ctx context.Context, obj *team.Team, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bucket.BucketOrder) (*pagination.Connection[*bucket.Bucket], error) + Configs(ctx context.Context, obj *team.Team, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *configmap.ConfigOrder, filter *configmap.ConfigFilter) (*pagination.Connection[*configmap.Config], error) Cost(ctx context.Context, obj *team.Team) (*cost.TeamCost, error) DeploymentKey(ctx context.Context, obj *team.Team) (*deployment.DeploymentKey, error) Deployments(ctx context.Context, obj *team.Team, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) (*pagination.Connection[*deployment.Deployment], error) @@ -90,6 +92,7 @@ type TeamEnvironmentResolver interface { Application(ctx context.Context, obj *team.TeamEnvironment, name string) (*application.Application, error) BigQueryDataset(ctx context.Context, obj *team.TeamEnvironment, name string) (*bigquery.BigQueryDataset, error) Bucket(ctx context.Context, obj *team.TeamEnvironment, name string) (*bucket.Bucket, error) + Config(ctx context.Context, obj *team.TeamEnvironment, name string) (*configmap.Config, error) Cost(ctx context.Context, obj *team.TeamEnvironment) (*cost.TeamEnvironmentCost, error) Environment(ctx context.Context, obj *team.TeamEnvironment) (*environment.Environment, error) Job(ctx context.Context, obj *team.TeamEnvironment, name string) (*job.Job, error) @@ -105,6 +108,7 @@ type TeamInventoryCountsResolver interface { Applications(ctx context.Context, obj *team.TeamInventoryCounts) (*application.TeamInventoryCountApplications, error) BigQueryDatasets(ctx context.Context, obj *team.TeamInventoryCounts) (*bigquery.TeamInventoryCountBigQueryDatasets, error) Buckets(ctx context.Context, obj *team.TeamInventoryCounts) (*bucket.TeamInventoryCountBuckets, error) + Configs(ctx context.Context, obj *team.TeamInventoryCounts) (*configmap.TeamInventoryCountConfigs, error) Jobs(ctx context.Context, obj *team.TeamInventoryCounts) (*job.TeamInventoryCountJobs, error) KafkaTopics(ctx context.Context, obj *team.TeamInventoryCounts) (*kafkatopic.TeamInventoryCountKafkaTopics, error) OpenSearches(ctx context.Context, obj *team.TeamInventoryCounts) (*opensearch.TeamInventoryCountOpenSearches, error) @@ -194,6 +198,17 @@ func (ec *executionContext) field_TeamEnvironment_bucket_args(ctx context.Contex return args, nil } +func (ec *executionContext) field_TeamEnvironment_config_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "name", ec.unmarshalNString2string) + if err != nil { + return nil, err + } + args["name"] = arg0 + return args, nil +} + func (ec *executionContext) field_TeamEnvironment_job_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -447,6 +462,42 @@ func (ec *executionContext) field_Team_buckets_args(ctx context.Context, rawArgs return args, nil } +func (ec *executionContext) field_Team_configs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOCursor2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐCursor) + if err != nil { + return nil, err + } + args["before"] = arg3 + arg4, err := graphql.ProcessArgField(ctx, rawArgs, "orderBy", ec.unmarshalOConfigOrder2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigOrder) + if err != nil { + return nil, err + } + args["orderBy"] = arg4 + arg5, err := graphql.ProcessArgField(ctx, rawArgs, "filter", ec.unmarshalOConfigFilter2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfigFilter) + if err != nil { + return nil, err + } + args["filter"] = arg5 + return args, nil +} + func (ec *executionContext) field_Team_deleteKey_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -1090,6 +1141,8 @@ func (ec *executionContext) fieldContext_CreateTeamPayload_team(_ context.Contex return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -1244,6 +1297,8 @@ func (ec *executionContext) fieldContext_RemoveTeamMemberPayload_team(_ context. return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -1782,6 +1837,8 @@ func (ec *executionContext) fieldContext_Team_environments(_ context.Context, fi return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1852,6 +1909,8 @@ func (ec *executionContext) fieldContext_Team_environment(ctx context.Context, f return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -1973,6 +2032,8 @@ func (ec *executionContext) fieldContext_Team_inventoryCounts(_ context.Context, return ec.fieldContext_TeamInventoryCounts_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_TeamInventoryCounts_buckets(ctx, field) + case "configs": + return ec.fieldContext_TeamInventoryCounts_configs(ctx, field) case "jobs": return ec.fieldContext_TeamInventoryCounts_jobs(ctx, field) case "kafkaTopics": @@ -2239,6 +2300,55 @@ func (ec *executionContext) fieldContext_Team_buckets(ctx context.Context, field return fc, nil } +func (ec *executionContext) _Team_configs(ctx context.Context, field graphql.CollectedField, obj *team.Team) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Team_configs, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Team().Configs(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*pagination.Cursor), fc.Args["last"].(*int), fc.Args["before"].(*pagination.Cursor), fc.Args["orderBy"].(*configmap.ConfigOrder), fc.Args["filter"].(*configmap.ConfigFilter)) + }, + nil, + ec.marshalNConfigConnection2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋpaginationᚐConnection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_Team_configs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Team", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "pageInfo": + return ec.fieldContext_ConfigConnection_pageInfo(ctx, field) + case "nodes": + return ec.fieldContext_ConfigConnection_nodes(ctx, field) + case "edges": + return ec.fieldContext_ConfigConnection_edges(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Team_configs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Team_cost(ctx context.Context, field graphql.CollectedField, obj *team.Team) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -3557,6 +3667,8 @@ func (ec *executionContext) fieldContext_TeamConnection_nodes(_ context.Context, return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -4297,6 +4409,8 @@ func (ec *executionContext) fieldContext_TeamDeleteKey_team(_ context.Context, f return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -4437,6 +4551,8 @@ func (ec *executionContext) fieldContext_TeamEdge_node(_ context.Context, field return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -4693,6 +4809,8 @@ func (ec *executionContext) fieldContext_TeamEnvironment_team(_ context.Context, return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -4848,6 +4966,8 @@ func (ec *executionContext) fieldContext_TeamEnvironment_application(ctx context return ec.fieldContext_Application_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Application_buckets(ctx, field) + case "configs": + return ec.fieldContext_Application_configs(ctx, field) case "cost": return ec.fieldContext_Application_cost(ctx, field) case "deployments": @@ -5018,6 +5138,71 @@ func (ec *executionContext) fieldContext_TeamEnvironment_bucket(ctx context.Cont return fc, nil } +func (ec *executionContext) _TeamEnvironment_config(ctx context.Context, field graphql.CollectedField, obj *team.TeamEnvironment) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_TeamEnvironment_config, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.TeamEnvironment().Config(ctx, obj, fc.Args["name"].(string)) + }, + nil, + ec.marshalNConfig2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐConfig, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_TeamEnvironment_config(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "TeamEnvironment", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Config_id(ctx, field) + case "name": + return ec.fieldContext_Config_name(ctx, field) + case "teamEnvironment": + return ec.fieldContext_Config_teamEnvironment(ctx, field) + case "team": + return ec.fieldContext_Config_team(ctx, field) + case "values": + return ec.fieldContext_Config_values(ctx, field) + case "applications": + return ec.fieldContext_Config_applications(ctx, field) + case "jobs": + return ec.fieldContext_Config_jobs(ctx, field) + case "workloads": + return ec.fieldContext_Config_workloads(ctx, field) + case "lastModifiedAt": + return ec.fieldContext_Config_lastModifiedAt(ctx, field) + case "lastModifiedBy": + return ec.fieldContext_Config_lastModifiedBy(ctx, field) + case "activityLog": + return ec.fieldContext_Config_activityLog(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Config", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_TeamEnvironment_config_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _TeamEnvironment_cost(ctx context.Context, field graphql.CollectedField, obj *team.TeamEnvironment) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -5149,6 +5334,8 @@ func (ec *executionContext) fieldContext_TeamEnvironment_job(ctx context.Context return ec.fieldContext_Job_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Job_buckets(ctx, field) + case "configs": + return ec.fieldContext_Job_configs(ctx, field) case "cost": return ec.fieldContext_Job_cost(ctx, field) case "deployments": @@ -6416,6 +6603,39 @@ func (ec *executionContext) fieldContext_TeamInventoryCounts_buckets(_ context.C return fc, nil } +func (ec *executionContext) _TeamInventoryCounts_configs(ctx context.Context, field graphql.CollectedField, obj *team.TeamInventoryCounts) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_TeamInventoryCounts_configs, + func(ctx context.Context) (any, error) { + return ec.Resolvers.TeamInventoryCounts().Configs(ctx, obj) + }, + nil, + ec.marshalNTeamInventoryCountConfigs2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋconfigmapᚐTeamInventoryCountConfigs, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_TeamInventoryCounts_configs(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "TeamInventoryCounts", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "total": + return ec.fieldContext_TeamInventoryCountConfigs_total(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type TeamInventoryCountConfigs", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _TeamInventoryCounts_jobs(ctx context.Context, field graphql.CollectedField, obj *team.TeamInventoryCounts) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -6711,6 +6931,8 @@ func (ec *executionContext) fieldContext_TeamMember_team(_ context.Context, fiel return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -8481,6 +8703,8 @@ func (ec *executionContext) fieldContext_UpdateTeamEnvironmentPayload_environmen return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -8550,6 +8774,8 @@ func (ec *executionContext) fieldContext_UpdateTeamEnvironmentPayload_teamEnviro return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -8641,6 +8867,8 @@ func (ec *executionContext) fieldContext_UpdateTeamPayload_team(_ context.Contex return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -9874,6 +10102,42 @@ func (ec *executionContext) _Team(ctx context.Context, sel ast.SelectionSet, obj continue } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "configs": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Team_configs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) case "cost": field := field @@ -11324,6 +11588,42 @@ func (ec *executionContext) _TeamEnvironment(ctx context.Context, sel ast.Select continue } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "config": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._TeamEnvironment_config(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) case "cost": field := field @@ -12145,6 +12445,42 @@ func (ec *executionContext) _TeamInventoryCounts(ctx context.Context, sel ast.Se continue } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "configs": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._TeamInventoryCounts_configs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) case "jobs": field := field diff --git a/internal/graph/gengql/utilization.generated.go b/internal/graph/gengql/utilization.generated.go index 4bb001488..162737366 100644 --- a/internal/graph/gengql/utilization.generated.go +++ b/internal/graph/gengql/utilization.generated.go @@ -249,6 +249,8 @@ func (ec *executionContext) fieldContext_TeamUtilizationData_team(_ context.Cont return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -396,6 +398,8 @@ func (ec *executionContext) fieldContext_TeamUtilizationData_environment(_ conte return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -465,6 +469,8 @@ func (ec *executionContext) fieldContext_TeamUtilizationData_teamEnvironment(_ c return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/gengql/valkey.generated.go b/internal/graph/gengql/valkey.generated.go index 6de71c798..bbf9a8c48 100644 --- a/internal/graph/gengql/valkey.generated.go +++ b/internal/graph/gengql/valkey.generated.go @@ -489,6 +489,8 @@ func (ec *executionContext) fieldContext_Valkey_team(_ context.Context, field gr return ec.fieldContext_Team_bigQueryDatasets(ctx, field) case "buckets": return ec.fieldContext_Team_buckets(ctx, field) + case "configs": + return ec.fieldContext_Team_configs(ctx, field) case "cost": return ec.fieldContext_Team_cost(ctx, field) case "deploymentKey": @@ -578,6 +580,8 @@ func (ec *executionContext) fieldContext_Valkey_environment(_ context.Context, f return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": @@ -647,6 +651,8 @@ func (ec *executionContext) fieldContext_Valkey_teamEnvironment(_ context.Contex return ec.fieldContext_TeamEnvironment_bigQueryDataset(ctx, field) case "bucket": return ec.fieldContext_TeamEnvironment_bucket(ctx, field) + case "config": + return ec.fieldContext_TeamEnvironment_config(ctx, field) case "cost": return ec.fieldContext_TeamEnvironment_cost(ctx, field) case "environment": diff --git a/internal/graph/schema/configmap.graphqls b/internal/graph/schema/configmap.graphqls new file mode 100644 index 000000000..57feaedea --- /dev/null +++ b/internal/graph/schema/configmap.graphqls @@ -0,0 +1,468 @@ +extend type Mutation { + "Create a new config." + createConfig(input: CreateConfigInput!): CreateConfigPayload! + + "Add a value to a config." + addConfigValue(input: AddConfigValueInput!): AddConfigValuePayload! + + "Update a value within a config." + updateConfigValue(input: UpdateConfigValueInput!): UpdateConfigValuePayload! + + "Remove a value from a config." + removeConfigValue(input: RemoveConfigValueInput!): RemoveConfigValuePayload! + + "Delete a config, and the values it contains." + deleteConfig(input: DeleteConfigInput!): DeleteConfigPayload! +} + +extend type Team { + "Configs owned by the team." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: ConfigOrder + + "Filtering options for items returned from the connection." + filter: ConfigFilter + ): ConfigConnection! +} + +""" +Input for filtering the configs of a team. +""" +input ConfigFilter { + """ + Filter by the name of the config. + """ + name: String + + """ + Filter by usage of the config. + """ + inUse: Boolean +} + +extend type TeamEnvironment { + "Get a config by name." + config(name: String!): Config! +} + +extend interface Workload { + "Configs used by the workload." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ConfigConnection! +} + +extend type Application { + "Configs used by the application." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ConfigConnection! +} + +extend type Job { + "Configs used by the job." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ConfigConnection! +} + +"A config is a collection of key-value pairs." +type Config implements Node & ActivityLogger { + "The globally unique ID of the config." + id: ID! + + "The name of the config." + name: String! + + "The environment the config exists in." + teamEnvironment: TeamEnvironment! + + "The team that owns the config." + team: Team! + + "The values stored in the config." + values: [ConfigValue!]! + + "Applications that use the config." + applications( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ApplicationConnection! + + "Jobs that use the config." + jobs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): JobConnection! + + "Workloads that use the config." + workloads( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): WorkloadConnection! + + "Last time the config was modified." + lastModifiedAt: Time + + "User who last modified the config." + lastModifiedBy: User + + "Activity log associated with the config." + activityLog( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + + "Filter items." + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type TeamInventoryCounts { + """ + Config inventory count for a team. + """ + configs: TeamInventoryCountConfigs! +} + +""" +Config inventory count for a team. +""" +type TeamInventoryCountConfigs { + """ + Total number of configs. + """ + total: Int! +} + +input ConfigValueInput { + "The name of the config value." + name: String! + + "The value to set." + value: String! +} + +input CreateConfigInput { + "The name of the config." + name: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! +} + +input AddConfigValueInput { + "The name of the config." + name: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! + + "The config value to add." + value: ConfigValueInput! +} + +input UpdateConfigValueInput { + "The name of the config." + name: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! + + "The config value to update." + value: ConfigValueInput! +} + +input RemoveConfigValueInput { + "The name of the config." + configName: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! + + "The config value to remove." + valueName: String! +} + +input DeleteConfigInput { + "The name of the config." + name: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! +} + +type CreateConfigPayload { + "The created config." + config: Config +} + +input ConfigOrder { + "The field to order items by." + field: ConfigOrderField! + + "The direction to order items by." + direction: OrderDirection! +} + +enum ConfigOrderField { + "Order configs by name." + NAME + + "Order configs by the name of the environment." + ENVIRONMENT + + "Order configs by the last time it was modified." + LAST_MODIFIED_AT +} + +type AddConfigValuePayload { + "The updated config." + config: Config +} + +type UpdateConfigValuePayload { + "The updated config." + config: Config +} + +type RemoveConfigValuePayload { + "The updated config." + config: Config +} + +type DeleteConfigPayload { + "The deleted config." + configDeleted: Boolean +} + +type ConfigConnection { + "Pagination information." + pageInfo: PageInfo! + + "List of nodes." + nodes: [Config!]! + + "List of edges." + edges: [ConfigEdge!]! +} + +type ConfigEdge { + "Cursor for this edge that can be used for pagination." + cursor: Cursor! + + "The Config." + node: Config! +} + +type ConfigValue { + "The name of the config value." + name: String! + + "The config value itself." + value: String! +} + +extend enum ActivityLogEntryResourceType { + "All activity log entries related to configs will use this resource type." + CONFIG +} + +type ConfigCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} + +type ConfigUpdatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the entry." + data: ConfigUpdatedActivityLogEntryData! +} + +type ConfigUpdatedActivityLogEntryDataUpdatedField { + "The name of the field that was updated." + field: String! + + "The old value of the field." + oldValue: String + + "The new value of the field." + newValue: String +} + +type ConfigUpdatedActivityLogEntryData { + "The fields that were updated." + updatedFields: [ConfigUpdatedActivityLogEntryDataUpdatedField!]! +} + +type ConfigDeletedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} + +extend enum ActivityLogActivityType { + "Config was created." + CONFIG_CREATED + "Config was updated." + CONFIG_UPDATED + "Config was deleted." + CONFIG_DELETED +} diff --git a/internal/kubernetes/clientset.go b/internal/kubernetes/clientset.go index 347ca1e05..e649ef790 100644 --- a/internal/kubernetes/clientset.go +++ b/internal/kubernetes/clientset.go @@ -14,8 +14,8 @@ const ( labelManagedByVal = "console" labelKubernetesManagedByKey = "app.kubernetes.io/managed-by" - annotationLastModifiedAt = "console.nais.io/last-modified-at" - annotationLastModifiedBy = "console.nais.io/last-modified-by" + AnnotationLastModifiedAt = "console.nais.io/last-modified-at" + AnnotationLastModifiedBy = "console.nais.io/last-modified-by" ) func NewClientSets(clusterConfig ClusterConfigMap) (map[string]kubernetes.Interface, error) { @@ -74,9 +74,9 @@ func WithCommonAnnotations(mp map[string]string, user string) map[string]string if mp == nil { mp = make(map[string]string) } - mp[annotationLastModifiedAt] = time.Now().Format(time.RFC3339) + mp[AnnotationLastModifiedAt] = time.Now().Format(time.RFC3339) if user != "" { - mp[annotationLastModifiedBy] = user + mp[AnnotationLastModifiedBy] = user } return mp diff --git a/internal/kubernetes/watchers/watchers.go b/internal/kubernetes/watchers/watchers.go index 08bdf50fa..430ede3e9 100644 --- a/internal/kubernetes/watchers/watchers.go +++ b/internal/kubernetes/watchers/watchers.go @@ -15,6 +15,7 @@ import ( "github.com/nais/api/internal/unleash" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/secret" nais_io_v1 "github.com/nais/liberator/pkg/apis/nais.io/v1" @@ -41,6 +42,7 @@ type ( NamespaceWatcher = watcher.Watcher[*v1.Namespace] UnleashWatcher = watcher.Watcher[*unleash.UnleashInstance] SecretWatcher = watcher.Watcher[*secret.Secret] + ConfigMapWatcher = watcher.Watcher[*configmap.Config] ) type Watchers struct { @@ -60,6 +62,7 @@ type Watchers struct { NamespaceWatcher *NamespaceWatcher UnleashWatcher *UnleashWatcher SecretWatcher *SecretWatcher + ConfigMapWatcher *ConfigMapWatcher } func SetupWatchers( @@ -84,5 +87,6 @@ func SetupWatchers( NamespaceWatcher: team.NewNamespaceWatcher(ctx, watcherMgr), UnleashWatcher: unleash.NewWatcher(ctx, mgmtWatcherMgr), SecretWatcher: secret.NewWatcher(ctx, watcherMgr), + ConfigMapWatcher: configmap.NewWatcher(ctx, watcherMgr), } } diff --git a/internal/workload/application/models.go b/internal/workload/application/models.go index 47cafe781..971e7810d 100644 --- a/internal/workload/application/models.go +++ b/internal/workload/application/models.go @@ -44,10 +44,30 @@ func (a Application) ID() ident.Ident { func (a *Application) GetSecrets() []string { ret := make([]string, 0) for _, v := range a.Spec.EnvFrom { - ret = append(ret, v.Secret) + if v.Secret != "" { + ret = append(ret, v.Secret) + } + } + for _, v := range a.Spec.FilesFrom { + if v.Secret != "" { + ret = append(ret, v.Secret) + } + } + return ret +} + +// GetConfigs returns a list of configmap names used by the application +func (a *Application) GetConfigs() []string { + ret := make([]string, 0) + for _, v := range a.Spec.EnvFrom { + if v.ConfigMap != "" { + ret = append(ret, v.ConfigMap) + } } for _, v := range a.Spec.FilesFrom { - ret = append(ret, v.Secret) + if v.ConfigMap != "" { + ret = append(ret, v.ConfigMap) + } } return ret } diff --git a/internal/workload/configmap/activitylog.go b/internal/workload/configmap/activitylog.go new file mode 100644 index 000000000..17637ebde --- /dev/null +++ b/internal/workload/configmap/activitylog.go @@ -0,0 +1,65 @@ +package configmap + +import ( + "fmt" + + "github.com/nais/api/internal/activitylog" +) + +const ( + activityLogEntryResourceTypeConfig activitylog.ActivityLogEntryResourceType = "CONFIG" +) + +func init() { + activitylog.RegisterTransformer(activityLogEntryResourceTypeConfig, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { + switch entry.Action { + case activitylog.ActivityLogEntryActionCreated: + return ConfigCreatedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage("Created config"), + }, nil + case activitylog.ActivityLogEntryActionDeleted: + return ConfigDeletedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage("Deleted config"), + }, nil + case activitylog.ActivityLogEntryActionUpdated: + data, err := activitylog.UnmarshalData[ConfigUpdatedActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal config updated activity log entry data: %w", err) + } + + return ConfigUpdatedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage("Updated config"), + Data: data, + }, nil + default: + return nil, fmt.Errorf("unsupported config activity log entry action: %q", entry.Action) + } + }) + + activitylog.RegisterFilter("CONFIG_CREATED", activitylog.ActivityLogEntryActionCreated, activityLogEntryResourceTypeConfig) + activitylog.RegisterFilter("CONFIG_UPDATED", activitylog.ActivityLogEntryActionUpdated, activityLogEntryResourceTypeConfig) + activitylog.RegisterFilter("CONFIG_DELETED", activitylog.ActivityLogEntryActionDeleted, activityLogEntryResourceTypeConfig) +} + +type ConfigCreatedActivityLogEntry struct { + activitylog.GenericActivityLogEntry +} + +type ConfigUpdatedActivityLogEntry struct { + activitylog.GenericActivityLogEntry + Data *ConfigUpdatedActivityLogEntryData `json:"data"` +} + +type ConfigUpdatedActivityLogEntryData struct { + UpdatedFields []*ConfigUpdatedActivityLogEntryDataUpdatedField `json:"updatedFields"` +} + +type ConfigUpdatedActivityLogEntryDataUpdatedField struct { + Field string `json:"field"` + OldValue *string `json:"oldValue,omitempty"` + NewValue *string `json:"newValue,omitempty"` +} + +type ConfigDeletedActivityLogEntry struct { + activitylog.GenericActivityLogEntry +} diff --git a/internal/workload/configmap/dataloader.go b/internal/workload/configmap/dataloader.go new file mode 100644 index 000000000..3e87b9cf6 --- /dev/null +++ b/internal/workload/configmap/dataloader.go @@ -0,0 +1,50 @@ +package configmap + +import ( + "context" + + "github.com/nais/api/internal/kubernetes" + "github.com/nais/api/internal/kubernetes/watcher" + "github.com/sirupsen/logrus" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +type ctxKey int + +const loadersKey ctxKey = iota + +func NewLoaderContext(ctx context.Context, watcher *watcher.Watcher[*Config], log logrus.FieldLogger) context.Context { + return context.WithValue(ctx, loadersKey, &loaders{ + watcher: watcher, + log: log, + }) +} + +func NewWatcher(ctx context.Context, mgr *watcher.Manager) *watcher.Watcher[*Config] { + w := watcher.Watch( + mgr, + &Config{}, + watcher.WithConverter(func(o *unstructured.Unstructured, environmentName string) (any, bool) { + return toGraphConfig(o, environmentName) + }), + watcher.WithInformerFilter(kubernetes.IsManagedByConsoleLabelSelector()), + watcher.WithGVR(corev1.SchemeGroupVersion.WithResource("configmaps")), + ) + w.Start(ctx) + return w +} + +func fromContext(ctx context.Context) *loaders { + return ctx.Value(loadersKey).(*loaders) +} + +type loaders struct { + watcher *watcher.Watcher[*Config] + log logrus.FieldLogger +} + +// Watcher returns the configmap watcher +func (l *loaders) Watcher() *watcher.Watcher[*Config] { + return l.watcher +} diff --git a/internal/workload/configmap/errors.go b/internal/workload/configmap/errors.go new file mode 100644 index 000000000..a13c5ec18 --- /dev/null +++ b/internal/workload/configmap/errors.go @@ -0,0 +1,25 @@ +package configmap + +type errUnmanaged struct{} + +func (errUnmanaged) GraphError() string { + return "The config is not managed by Console, unable to modify." +} + +func (errUnmanaged) Error() string { + return "unmanaged config" +} + +var ErrUnmanaged = errUnmanaged{} + +type errAlreadyExists struct{} + +func (errAlreadyExists) GraphError() string { + return "A config with this name already exists." +} + +func (errAlreadyExists) Error() string { + return "config already exists" +} + +var ErrAlreadyExists = errAlreadyExists{} diff --git a/internal/workload/configmap/models.go b/internal/workload/configmap/models.go new file mode 100644 index 000000000..dbb0f32b8 --- /dev/null +++ b/internal/workload/configmap/models.go @@ -0,0 +1,207 @@ +package configmap + +import ( + "fmt" + "io" + "strconv" + "time" + + "github.com/nais/api/internal/graph/ident" + "github.com/nais/api/internal/graph/model" + "github.com/nais/api/internal/graph/pagination" + "github.com/nais/api/internal/kubernetes" + "github.com/nais/api/internal/slug" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +type ( + ConfigConnection = pagination.Connection[*Config] + ConfigEdge = pagination.Edge[*Config] +) + +type Config struct { + Name string `json:"name"` + LastModifiedAt *time.Time `json:"lastModifiedAt"` + ModifiedByUserEmail *string `json:"lastModifiedBy"` + Data map[string]string `json:"-"` // ConfigMap data cached as-is (not sensitive) + + TeamSlug slug.Slug `json:"-"` + EnvironmentName string `json:"-"` +} + +type CreateConfigInput struct { + Name string `json:"name"` + EnvironmentName string `json:"environmentName"` + TeamSlug slug.Slug `json:"teamSlug"` +} + +type CreateConfigPayload struct { + Config *Config `json:"config"` +} + +type UpdateConfigInput struct { + Name string `json:"name"` + EnvironmentName string `json:"environmentName"` + TeamSlug slug.Slug `json:"teamSlug"` + Data []*ConfigValueInput `json:"data"` +} + +type UpdateConfigPayload struct { + Config *Config `json:"config"` +} + +type ConfigValueInput struct { + Name string `json:"name"` + Value string `json:"value"` +} + +func (c *Config) ID() ident.Ident { + return newIdent(c.TeamSlug, c.EnvironmentName, c.Name) +} + +func (Config) IsNode() {} + +func (c *Config) GetName() string { + return c.Name +} + +func (c *Config) GetNamespace() string { + return c.TeamSlug.String() +} + +func (c *Config) GetLabels() map[string]string { + return nil +} + +func (c *Config) DeepCopyObject() runtime.Object { + return c +} + +func (c *Config) GetObjectKind() schema.ObjectKind { + return schema.EmptyObjectKind +} + +func toGraphConfig(o *unstructured.Unstructured, environmentName string) (*Config, bool) { + if !configIsManagedByConsole(o) { + return nil, false + } + + var lastModifiedAt *time.Time + if t, ok := o.GetAnnotations()[kubernetes.AnnotationLastModifiedAt]; ok { + tm, err := time.Parse(time.RFC3339, t) + if err == nil { + lastModifiedAt = &tm + } + } + + var lastModifiedBy *string + if email, ok := o.GetAnnotations()[kubernetes.AnnotationLastModifiedBy]; ok { + lastModifiedBy = &email + } + + // ConfigMap data is not sensitive, so we keep it as-is + data, _, _ := unstructured.NestedStringMap(o.Object, "data") + + return &Config{ + Name: o.GetName(), + TeamSlug: slug.Slug(o.GetNamespace()), + EnvironmentName: environmentName, + LastModifiedAt: lastModifiedAt, + ModifiedByUserEmail: lastModifiedBy, + Data: data, + }, true +} + +type ConfigValue struct { + Name string `json:"name"` + Value string `json:"value"` +} + +type DeleteConfigInput struct { + Name string `json:"name"` + EnvironmentName string `json:"environmentName"` + TeamSlug slug.Slug `json:"teamSlug"` +} + +type DeleteConfigPayload struct { + ConfigDeleted bool `json:"configDeleted"` +} + +type AddConfigValueInput struct { + Name string `json:"name"` + EnvironmentName string `json:"environmentName"` + TeamSlug slug.Slug `json:"teamSlug"` + Value *ConfigValueInput `json:"value"` +} + +type UpdateConfigValueInput struct { + Name string `json:"name"` + EnvironmentName string `json:"environmentName"` + TeamSlug slug.Slug `json:"teamSlug"` + Value *ConfigValueInput `json:"value"` +} + +type RemoveConfigValueInput struct { + ConfigName string `json:"configName"` + EnvironmentName string `json:"environmentName"` + TeamSlug slug.Slug `json:"teamSlug"` + ValueName string `json:"valueName"` +} + +type AddConfigValuePayload struct { + Config *Config `json:"config"` +} + +type UpdateConfigValuePayload struct { + Config *Config `json:"config"` +} + +type RemoveConfigValuePayload struct { + Config *Config `json:"config"` +} + +type ConfigOrder struct { + Field ConfigOrderField `json:"field"` + Direction model.OrderDirection `json:"direction"` +} + +type ConfigOrderField string + +func (e ConfigOrderField) IsValid() bool { + return SortFilter.SupportsSort(e) +} + +func (e ConfigOrderField) String() string { + return string(e) +} + +func (e *ConfigOrderField) UnmarshalGQL(v any) error { + str, ok := v.(string) + if !ok { + return fmt.Errorf("enums must be strings") + } + + *e = ConfigOrderField(str) + if !e.IsValid() { + return fmt.Errorf("%s is not a valid ConfigOrderField", str) + } + return nil +} + +func (e ConfigOrderField) MarshalGQL(w io.Writer) { + fmt.Fprint(w, strconv.Quote(e.String())) +} + +type ConfigFilter struct { + Name *string `json:"name"` + InUse *bool `json:"inUse"` +} + +// IsActivityLogger implements the ActivityLogger interface. +func (Config) IsActivityLogger() {} + +type TeamInventoryCountConfigs struct { + Total int `json:"total"` +} diff --git a/internal/workload/configmap/node.go b/internal/workload/configmap/node.go new file mode 100644 index 000000000..5d1913ba1 --- /dev/null +++ b/internal/workload/configmap/node.go @@ -0,0 +1,31 @@ +package configmap + +import ( + "fmt" + + "github.com/nais/api/internal/graph/ident" + "github.com/nais/api/internal/slug" +) + +type identType int + +const ( + identKey identType = iota +) + +func init() { + ident.RegisterIdentType(identKey, "CFG", GetByIdent) +} + +func newIdent(teamSlug slug.Slug, environment, name string) ident.Ident { + return ident.NewIdent(identKey, teamSlug.String(), environment, name) +} + +func parseIdent(id ident.Ident) (teamSlug slug.Slug, environment, name string, err error) { + parts := id.Parts() + if len(parts) != 3 { + return "", "", "", fmt.Errorf("invalid config ident") + } + + return slug.Slug(parts[0]), parts[1], parts[2], nil +} diff --git a/internal/workload/configmap/queries.go b/internal/workload/configmap/queries.go new file mode 100644 index 000000000..44aa88c03 --- /dev/null +++ b/internal/workload/configmap/queries.go @@ -0,0 +1,478 @@ +package configmap + +import ( + "context" + "encoding/json" + "fmt" + "slices" + "strings" + + "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/auth/authz" + "github.com/nais/api/internal/graph/apierror" + "github.com/nais/api/internal/graph/ident" + "github.com/nais/api/internal/graph/model" + "github.com/nais/api/internal/graph/pagination" + "github.com/nais/api/internal/kubernetes" + "github.com/nais/api/internal/kubernetes/watcher" + "github.com/nais/api/internal/slug" + "github.com/nais/api/internal/workload" + corev1 "k8s.io/api/core/v1" + k8serrors "k8s.io/apimachinery/pkg/api/errors" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/validation" +) + +func ListForWorkload(ctx context.Context, teamSlug slug.Slug, environmentName string, w workload.Workload, page *pagination.Pagination) (*ConfigConnection, error) { + configNames := w.GetConfigs() + allConfigs := watcher.Objects(fromContext(ctx).Watcher().GetByNamespace(teamSlug.String(), watcher.InCluster(environmentName))) + + ret := make([]*Config, 0, len(allConfigs)) + for _, c := range allConfigs { + if slices.Contains(configNames, c.Name) { + ret = append(ret, c) + } + } + + SortFilter.Sort(ctx, ret, "NAME", model.OrderDirectionAsc) + paginated := pagination.Slice(ret, page) + return pagination.NewConnection(paginated, page, len(ret)), nil +} + +func ListForTeam(ctx context.Context, teamSlug slug.Slug, page *pagination.Pagination, orderBy *ConfigOrder, filter *ConfigFilter) (*ConfigConnection, error) { + allConfigs := watcher.Objects(fromContext(ctx).Watcher().GetByNamespace(teamSlug.String())) + + if orderBy == nil { + orderBy = &ConfigOrder{ + Field: "NAME", + Direction: model.OrderDirectionAsc, + } + } + + filtered := SortFilter.Filter(ctx, allConfigs, filter) + SortFilter.Sort(ctx, filtered, orderBy.Field, orderBy.Direction) + + configs := pagination.Slice(filtered, page) + return pagination.NewConnection(configs, page, len(filtered)), nil +} + +func CountForTeam(ctx context.Context, teamSlug slug.Slug) int { + return len(fromContext(ctx).Watcher().GetByNamespace(teamSlug.String())) +} + +func Get(ctx context.Context, teamSlug slug.Slug, environment, name string) (*Config, error) { + config, err := fromContext(ctx).Watcher().Get(environment, teamSlug.String(), name) + if err != nil { + return nil, err + } + return config, nil +} + +func GetByIdent(ctx context.Context, id ident.Ident) (*Config, error) { + teamSlug, env, name, err := parseIdent(id) + if err != nil { + return nil, err + } + return Get(ctx, teamSlug, env, name) +} + +// GetConfigValues returns the config values directly from the cached data. +// ConfigMap data is not sensitive, so no elevation is needed. +func GetConfigValues(ctx context.Context, teamSlug slug.Slug, environmentName, name string) ([]*ConfigValue, error) { + config, err := fromContext(ctx).Watcher().Get(environmentName, teamSlug.String(), name) + if err != nil { + return nil, err + } + + values := make([]*ConfigValue, 0, len(config.Data)) + for k, v := range config.Data { + values = append(values, &ConfigValue{ + Name: k, + Value: v, + }) + } + + slices.SortFunc(values, func(a, b *ConfigValue) int { + return strings.Compare(a.Name, b.Name) + }) + + return values, nil +} + +func Create(ctx context.Context, teamSlug slug.Slug, environment, name string) (*Config, error) { + w := fromContext(ctx).Watcher() + client, err := w.ImpersonatedClient(ctx, environment) + if err != nil { + return nil, err + } + + if nameErrs := validation.IsDNS1123Subdomain(name); len(nameErrs) > 0 { + return nil, fmt.Errorf("invalid name %q: %s", name, strings.Join(nameErrs, ", ")) + } + + actor := authz.ActorFromContext(ctx) + + cm := &corev1.ConfigMap{ + ObjectMeta: v1.ObjectMeta{ + Name: name, + Namespace: teamSlug.String(), + Annotations: annotations(actor.User.Identity()), + }, + } + + kubernetes.SetManagedByConsoleLabel(cm) + + u, err := runtime.DefaultUnstructuredConverter.ToUnstructured(cm) + if err != nil { + return nil, err + } + + created, err := client.Namespace(teamSlug.String()).Create(ctx, &unstructured.Unstructured{Object: u}, v1.CreateOptions{}) + if err != nil { + if k8serrors.IsAlreadyExists(err) { + return nil, ErrAlreadyExists + } + return nil, fmt.Errorf("creating config: %w", err) + } + + err = activitylog.Create(ctx, activitylog.CreateInput{ + Action: activitylog.ActivityLogEntryActionCreated, + Actor: actor.User, + EnvironmentName: &environment, + ResourceType: activityLogEntryResourceTypeConfig, + ResourceName: name, + TeamSlug: &teamSlug, + }) + if err != nil { + fromContext(ctx).log.WithError(err).Errorf("unable to create activity log entry") + } + + retVal, ok := toGraphConfig(created, environment) + if !ok { + return nil, fmt.Errorf("failed to convert configmap to graph config") + } + return retVal, nil +} + +func AddConfigValue(ctx context.Context, teamSlug slug.Slug, environment, configName string, valueToAdd *ConfigValueInput) (*Config, error) { + if err := validateConfigValue(valueToAdd); err != nil { + return nil, err + } + + w := fromContext(ctx).Watcher() + client, err := w.ImpersonatedClient(ctx, environment) + if err != nil { + return nil, err + } + + // Check if the configmap exists and is managed by console + obj, err := client.Namespace(teamSlug.String()).Get(ctx, configName, v1.GetOptions{}) + if err != nil { + return nil, err + } + + if !configIsManagedByConsole(obj) { + return nil, ErrUnmanaged + } + + // Check if key already exists + data, dataExists, _ := unstructured.NestedMap(obj.Object, "data") + if _, exists := data[valueToAdd.Name]; exists { + return nil, apierror.Errorf("The config already contains a value with the name %q.", valueToAdd.Name) + } + + // Use JSON Patch to add the new key + actor := authz.ActorFromContext(ctx) + + var patch []map[string]any + if !dataExists || data == nil { + patch = []map[string]any{ + {"op": "add", "path": "/data", "value": map[string]any{valueToAdd.Name: valueToAdd.Value}}, + {"op": "replace", "path": "/metadata/annotations", "value": annotations(actor.User.Identity())}, + } + } else { + patch = []map[string]any{ + {"op": "add", "path": "/data/" + escapeJSONPointer(valueToAdd.Name), "value": valueToAdd.Value}, + {"op": "replace", "path": "/metadata/annotations", "value": annotations(actor.User.Identity())}, + } + } + + patchBytes, err := json.Marshal(patch) + if err != nil { + return nil, fmt.Errorf("marshaling patch: %w", err) + } + + _, err = client.Namespace(teamSlug.String()).Patch(ctx, configName, types.JSONPatchType, patchBytes, v1.PatchOptions{}) + if err != nil { + return nil, fmt.Errorf("patching config: %w", err) + } + + err = activitylog.Create(ctx, activitylog.CreateInput{ + Action: activitylog.ActivityLogEntryActionUpdated, + Actor: actor.User, + EnvironmentName: &environment, + ResourceType: activityLogEntryResourceTypeConfig, + ResourceName: configName, + TeamSlug: &teamSlug, + Data: ConfigUpdatedActivityLogEntryData{ + UpdatedFields: []*ConfigUpdatedActivityLogEntryDataUpdatedField{ + { + Field: valueToAdd.Name, + NewValue: &valueToAdd.Value, + }, + }, + }, + }) + if err != nil { + fromContext(ctx).log.WithError(err).Errorf("unable to create activity log entry") + } + + // Re-fetch from the K8s API to return up-to-date data + updated, err := client.Namespace(teamSlug.String()).Get(ctx, configName, v1.GetOptions{}) + if err != nil { + return nil, fmt.Errorf("fetching updated config: %w", err) + } + + retVal, ok := toGraphConfig(updated, environment) + if !ok { + return nil, fmt.Errorf("failed to convert configmap") + } + return retVal, nil +} + +func UpdateConfigValue(ctx context.Context, teamSlug slug.Slug, environment, configName string, valueToUpdate *ConfigValueInput) (*Config, error) { + if err := validateConfigValue(valueToUpdate); err != nil { + return nil, err + } + + w := fromContext(ctx).Watcher() + client, err := w.ImpersonatedClient(ctx, environment) + if err != nil { + return nil, err + } + + // Check if the configmap exists and is managed by console + obj, err := client.Namespace(teamSlug.String()).Get(ctx, configName, v1.GetOptions{}) + if err != nil { + return nil, err + } + + if !configIsManagedByConsole(obj) { + return nil, ErrUnmanaged + } + + // Check if key exists + data, _, _ := unstructured.NestedMap(obj.Object, "data") + oldValueRaw, exists := data[valueToUpdate.Name] + if !exists { + return nil, apierror.Errorf("The config does not contain a value with the name %q.", valueToUpdate.Name) + } + + var oldValue *string + if s, ok := oldValueRaw.(string); ok { + oldValue = &s + } + + // Use JSON Patch to update the key + actor := authz.ActorFromContext(ctx) + + patch := []map[string]any{ + {"op": "replace", "path": "/data/" + escapeJSONPointer(valueToUpdate.Name), "value": valueToUpdate.Value}, + {"op": "replace", "path": "/metadata/annotations", "value": annotations(actor.User.Identity())}, + } + + patchBytes, err := json.Marshal(patch) + if err != nil { + return nil, fmt.Errorf("marshaling patch: %w", err) + } + + _, err = client.Namespace(teamSlug.String()).Patch(ctx, configName, types.JSONPatchType, patchBytes, v1.PatchOptions{}) + if err != nil { + return nil, fmt.Errorf("patching config: %w", err) + } + + err = activitylog.Create(ctx, activitylog.CreateInput{ + Action: activitylog.ActivityLogEntryActionUpdated, + Actor: actor.User, + EnvironmentName: &environment, + ResourceType: activityLogEntryResourceTypeConfig, + ResourceName: configName, + TeamSlug: &teamSlug, + Data: ConfigUpdatedActivityLogEntryData{ + UpdatedFields: []*ConfigUpdatedActivityLogEntryDataUpdatedField{ + { + Field: valueToUpdate.Name, + OldValue: oldValue, + NewValue: &valueToUpdate.Value, + }, + }, + }, + }) + if err != nil { + fromContext(ctx).log.WithError(err).Errorf("unable to create activity log entry") + } + + // Re-fetch from the K8s API to return up-to-date data + updated, err := client.Namespace(teamSlug.String()).Get(ctx, configName, v1.GetOptions{}) + if err != nil { + return nil, fmt.Errorf("fetching updated config: %w", err) + } + + retVal, ok := toGraphConfig(updated, environment) + if !ok { + return nil, fmt.Errorf("failed to convert configmap") + } + return retVal, nil +} + +func RemoveConfigValue(ctx context.Context, teamSlug slug.Slug, environment, configName, valueName string) (*Config, error) { + w := fromContext(ctx).Watcher() + client, err := w.ImpersonatedClient(ctx, environment) + if err != nil { + return nil, err + } + + // Check if the configmap exists and is managed by console + obj, err := client.Namespace(teamSlug.String()).Get(ctx, configName, v1.GetOptions{}) + if err != nil { + return nil, err + } + + if !configIsManagedByConsole(obj) { + return nil, ErrUnmanaged + } + + // Check if key exists + data, _, _ := unstructured.NestedMap(obj.Object, "data") + oldValueRaw, exists := data[valueName] + if !exists { + return nil, apierror.Errorf("The config does not contain a value with the name: %q.", valueName) + } + + var oldValue *string + if s, ok := oldValueRaw.(string); ok { + oldValue = &s + } + + // Use JSON Patch to remove the key + actor := authz.ActorFromContext(ctx) + + patch := []map[string]any{ + {"op": "remove", "path": "/data/" + escapeJSONPointer(valueName)}, + {"op": "replace", "path": "/metadata/annotations", "value": annotations(actor.User.Identity())}, + } + + patchBytes, err := json.Marshal(patch) + if err != nil { + return nil, fmt.Errorf("marshaling patch: %w", err) + } + + _, err = client.Namespace(teamSlug.String()).Patch(ctx, configName, types.JSONPatchType, patchBytes, v1.PatchOptions{}) + if err != nil { + return nil, fmt.Errorf("patching config: %w", err) + } + + err = activitylog.Create(ctx, activitylog.CreateInput{ + Action: activitylog.ActivityLogEntryActionUpdated, + Actor: actor.User, + EnvironmentName: &environment, + ResourceType: activityLogEntryResourceTypeConfig, + ResourceName: configName, + TeamSlug: &teamSlug, + Data: ConfigUpdatedActivityLogEntryData{ + UpdatedFields: []*ConfigUpdatedActivityLogEntryDataUpdatedField{ + { + Field: valueName, + OldValue: oldValue, + }, + }, + }, + }) + if err != nil { + fromContext(ctx).log.WithError(err).Errorf("unable to create activity log entry") + } + + // Re-fetch from the K8s API to return up-to-date data + updated, err := client.Namespace(teamSlug.String()).Get(ctx, configName, v1.GetOptions{}) + if err != nil { + return nil, fmt.Errorf("fetching updated config: %w", err) + } + + retVal, ok := toGraphConfig(updated, environment) + if !ok { + return nil, fmt.Errorf("failed to convert configmap") + } + return retVal, nil +} + +func Delete(ctx context.Context, teamSlug slug.Slug, environment, name string) error { + w := fromContext(ctx).Watcher() + client, err := w.ImpersonatedClient(ctx, environment) + if err != nil { + return err + } + + obj, err := client.Namespace(teamSlug.String()).Get(ctx, name, v1.GetOptions{}) + if err != nil { + if k8serrors.IsNotFound(err) { + return &watcher.ErrorNotFound{Cluster: environment, Namespace: teamSlug.String(), Name: name} + } + return err + } + + if !configIsManagedByConsole(obj) { + return ErrUnmanaged + } + + if err := client.Namespace(teamSlug.String()).Delete(ctx, name, v1.DeleteOptions{}); err != nil { + return err + } + + err = activitylog.Create(ctx, activitylog.CreateInput{ + Action: activitylog.ActivityLogEntryActionDeleted, + Actor: authz.ActorFromContext(ctx).User, + EnvironmentName: &environment, + ResourceType: activityLogEntryResourceTypeConfig, + ResourceName: name, + TeamSlug: &teamSlug, + }) + if err != nil { + fromContext(ctx).log.WithError(err).Errorf("unable to create activity log entry") + } + + return nil +} + +func annotations(user string) map[string]string { + m := map[string]string{ + "reloader.stakater.com/match": "true", + } + return kubernetes.WithCommonAnnotations(m, user) +} + +func validateConfigValue(value *ConfigValueInput) error { + if errs := validation.IsConfigMapKey(value.Name); len(errs) > 0 { + return fmt.Errorf("invalid config key %q: %s", value.Name, strings.Join(errs, ", ")) + } + + return nil +} + +func configIsManagedByConsole(cm *unstructured.Unstructured) bool { + hasConsoleLabel := kubernetes.HasManagedByConsoleLabel(cm) + hasOwnerReferences := len(cm.GetOwnerReferences()) > 0 + hasFinalizers := len(cm.GetFinalizers()) > 0 + + return hasConsoleLabel && !hasOwnerReferences && !hasFinalizers +} + +// escapeJSONPointer escapes special characters in JSON Pointer (RFC 6901) +// ~ becomes ~0, / becomes ~1 +func escapeJSONPointer(s string) string { + s = strings.ReplaceAll(s, "~", "~0") + s = strings.ReplaceAll(s, "/", "~1") + return s +} diff --git a/internal/workload/configmap/sortfilter.go b/internal/workload/configmap/sortfilter.go new file mode 100644 index 000000000..98226928d --- /dev/null +++ b/internal/workload/configmap/sortfilter.go @@ -0,0 +1,70 @@ +package configmap + +import ( + "context" + "slices" + "strings" + + "github.com/nais/api/internal/graph/sortfilter" + "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/job" +) + +var SortFilter = sortfilter.New[*Config, ConfigOrderField, *ConfigFilter]() + +func init() { + SortFilter.RegisterSort("NAME", func(ctx context.Context, a, b *Config) int { + return strings.Compare(a.GetName(), b.GetName()) + }, "ENVIRONMENT") + SortFilter.RegisterSort("ENVIRONMENT", func(ctx context.Context, a, b *Config) int { + return strings.Compare(a.EnvironmentName, b.EnvironmentName) + }, "NAME") + SortFilter.RegisterSort("LAST_MODIFIED_AT", func(ctx context.Context, a, b *Config) int { + if a.LastModifiedAt == nil && b.LastModifiedAt == nil { + return 0 + } + if a.LastModifiedAt == nil { + return -1 + } + if b.LastModifiedAt == nil { + return 1 + } + return a.LastModifiedAt.Compare(*b.LastModifiedAt) + }, "NAME", "ENVIRONMENT") + + SortFilter.RegisterFilter(func(ctx context.Context, v *Config, filter *ConfigFilter) bool { + if filter.Name != nil && *filter.Name != "" { + if !strings.Contains(strings.ToLower(v.Name), strings.ToLower(*filter.Name)) { + return false + } + } + + if filter.InUse != nil { + inUse := false + + applications := application.ListAllForTeamInEnvironment(ctx, v.TeamSlug, v.EnvironmentName) + for _, app := range applications { + if slices.Contains(app.GetConfigs(), v.Name) { + inUse = true + break + } + } + + if !inUse { + jobs := job.ListAllForTeamInEnvironment(ctx, v.TeamSlug, v.EnvironmentName) + for _, j := range jobs { + if slices.Contains(j.GetConfigs(), v.Name) { + inUse = true + break + } + } + } + + if inUse != *filter.InUse { + return false + } + } + + return true + }) +} diff --git a/internal/workload/job/models.go b/internal/workload/job/models.go index cee28763f..cb7214bce 100644 --- a/internal/workload/job/models.go +++ b/internal/workload/job/models.go @@ -51,10 +51,30 @@ func (Job) IsActivityLogger() {} func (j *Job) GetSecrets() []string { ret := make([]string, 0) for _, v := range j.Spec.EnvFrom { - ret = append(ret, v.Secret) + if v.Secret != "" { + ret = append(ret, v.Secret) + } + } + for _, v := range j.Spec.FilesFrom { + if v.Secret != "" { + ret = append(ret, v.Secret) + } + } + return ret +} + +// GetConfigs returns a list of configmap names used by the job +func (j *Job) GetConfigs() []string { + ret := make([]string, 0) + for _, v := range j.Spec.EnvFrom { + if v.ConfigMap != "" { + ret = append(ret, v.ConfigMap) + } } for _, v := range j.Spec.FilesFrom { - ret = append(ret, v.Secret) + if v.ConfigMap != "" { + ret = append(ret, v.ConfigMap) + } } return ret } diff --git a/internal/workload/models.go b/internal/workload/models.go index c7e1ccb8e..29b987214 100644 --- a/internal/workload/models.go +++ b/internal/workload/models.go @@ -38,6 +38,9 @@ type Workload interface { // GetSecrets returns a list of secret names used by the workload GetSecrets() []string + + // GetConfigs returns a list of configmap names used by the workload + GetConfigs() []string Image() *ContainerImage }