scalar Long
scalar DateTime
"""
A string representing a duration, the format is a string that starts with a number and ends with a time unit.
Examples: "1s", "100ms", "1m30s", "1h"
"""
scalar Duration

enum EventHubType {
  KAFKA
}

interface EventHub {
  name: String!
  description: String
  uuid: ID!
  type: EventHubType!
}

type KafkaEventHub implements EventHub @key(fields: "name") {
  name: String!
  description: String
  uuid: ID!
  type: EventHubType!
  bootstrapServers: String!
  properties: [KafkaProperty!]
}

type KafkaProperty {
  key: String!
  value: String!
}

union EventHubs = KafkaEventHub

type EventHubTopic {
  name: String!
}

enum StorageType {
  AZURE
  GCS
  S3
  VOLUME
}

interface Storage {
  name: String!
  description: String
  uuid: ID!
  type: StorageType!
}

type AzureStorage implements Storage @key(fields: "name") {
  uuid: ID!
  name: String!
  description: String
  type: StorageType!
  container: String!
  location: String!
  directory: String
  storageURI: String!
}

type GcsStorage implements Storage @key(fields: "name") {
  uuid: ID!
  name: String!
  description: String
  type: StorageType!
  bucketName: String!
  bucketPrefix: String
  bucketURI: String!
}

type S3Storage implements Storage @key(fields: "name") {
  uuid: ID!
  name: String!
  description: String
  type: StorageType!
  bucketName: String!
  bucketRegion: String!
  bucketPrefix: String
  bucketURI: String!
}

type VolumeStorage implements Storage @key(fields: "name") {
  uuid: ID!
  name: String!
  description: String
  type: StorageType!
  capacity: String!
}

union Storages = AzureStorage | GcsStorage | S3Storage | VolumeStorage

interface Credentials {
  name: String!
  uuid: ID!
}

enum Mechanism {
  PLAIN
  SCRAMSHA256
  SCRAMSHA512
}

type SaslCredentials implements Credentials @key(fields: "name") {
  name: String!
  uuid: ID!
  mechanism: Mechanism!
  useSsl: Boolean!
}

type MTlsCredentials implements Credentials @key(fields: "name") {
  name: String!
  uuid: ID!
}

type AzureCredentials implements Credentials @key(fields: "name") {
  name: String!
  uuid: ID!
}

type AwsCredentials implements Credentials @key(fields: "name") {
  name: String!
  uuid: ID!
}

type GcpCredentials implements Credentials @key(fields: "name") {
  name: String!
  uuid: ID!
}

union CredentialsUnion = AzureCredentials| AwsCredentials | GcpCredentials | SaslCredentials | MTlsCredentials


type ServiceAccount @key(fields: "name") {
  name: String!
}

type EventHubRef {
  name: String!
  eventHub: EventHub
}

type StorageRef {
  name: String!
  storage: Storages
}

type CredentialsRef {
  name: String!
  credentials: Credentials
}

type Backup @key(fields: "name") {
  name: String!
  uuid: ID!
  description: String
  sourceRef: EventHubRef!
  sourceCredentialsRef: CredentialsRef
  sourceAdditionalProperties: [AdditionalProperty!]
  sinkRef: StorageRef!
  sinkCredentialsRef: CredentialsRef
  sinkAdditionalProperties: [AdditionalProperty!]
  serviceAccount: String
  streams: [BackupStream!]!
  segmentRolloverTriggers: SegmentRolloverTriggers
  dataRetentionPolicy: DataRetentionPolicy
  compression: BackupCompression!
  resources: ResourceRequirements
  paused: Boolean!
  status: BackupStatus!
  createdAt: DateTime!
  lastUpdatedAt: DateTime!
}

enum BackupStatus {
  """
  The backup has been created, but the configuration is not yet complete
  """
  DRAFT,

  """
  The backup is ready to be started
  """
  READY,

  """
  The backup is currently running
  """
  RUNNING,

  """
  The backup has been paused
  """
  PAUSED

  """
  The backup has errors
  """
  ERROR
}

type BackupStream {
  topic: String!
  status: BackupStreamStatus!
}

enum BackupStreamStatus {
  ACTIVE,
  PAUSED
}

type SegmentRolloverTriggers {
  size: String
  timeoutSeconds: Long
}

type DataRetentionPolicy {
  delete: DeleteDataRetentionPolicy
}

type DeleteDataRetentionPolicy {
  after: String
}

type BackupCompression {
  algorithm: BackupCompressionAlgorithm!
  quality: Int
}

enum BackupCompressionAlgorithm {
  NONE
  ZSTD
  GZIP
  BZIP2
  XZ
  DEFLATE
  BROTLI
  LZMA
  ZLIB
}

type AdditionalProperty {
  key: String
  value: String
}

type Restore @key(fields: "id") {
  id: ID!
  uuid: ID!
  description: String
  status: RestoreStatus!
  backupRef: BackupRef
  config: RestoreConfiguration!
  createdAt: DateTime!
  lastUpdatedAt: DateTime!
  startedAt: DateTime
  completedAt: DateTime
}

type BackupRef {
  name: String!
  backup: Backup
}

enum RestoreStatus {
  """
  The restore has been created, but the configuration is not yet complete
  """
  DRAFT,

  """
  The restore is ready to be started
  """
  READY,

  """
  The restore is enabled, but not yet started
  """
  INITIALIZING,

  """
  The restore is currently running
  """
  RUNNING,

  """
  The restore has run to completion successfully
  """
  DONE

  """
  The configuration of the restore contains an error
  """
  INVALID_CONFIGURATION

  """
  The restore has failed
  """
  FAILED
}

type RestoreConfiguration {
  sourceRef: StorageRef
  sourceCredentialsRef: CredentialsRef
  sourceAdditionalProperties: [AdditionalProperty!]
  sinkRef: EventHubRef
  sinkCredentialsRef: CredentialsRef
  sinkAdditionalProperties: [AdditionalProperty!]
  serviceAccount: String
  topics: [RestoreTopicConfiguration!]!
  restoreFrom: DateTime
  restoreUntil: DateTime
  legacyOffsetHeader: String
  parallelism: Int
  maxProducers: Int
  resources: ResourceRequirements
}

type RestoreTopicConfiguration {
  source: String!
  target: String!
  disablePreflightChecks: Boolean
  partitions: [RestorePartitionConfiguration!]!
}

type RestorePartitionConfiguration {
  number: Int!
  restoreFromOffset: Long
  restoreUntilOffset: Long
}

input ConfigureKafkaEventHubInput {

  """
  UUID of the event hub.
  If not provided, a new event hub will be created.
  If provided, the existing event hub will be updated.
  If the UUID does not exist, an error will be returned.
  """
  uuid: String

  """
  Name of the event hub
  """
  name: String!
  description: String
  bootstrapServers: String!
  properties: [KafkaPropertyInput!]
}

input KafkaPropertyInput {
  key: String!
  value: String!
}

union ConfigureKafkaEventHubPayload =
  KafkaEventHubConfigured
  | KafkaEventHubConfigurationFailed

type KafkaEventHubConfigured {
  eventHub: KafkaEventHub!
}

type KafkaEventHubConfigurationFailed {
  problems: [KafkaEventHubConfigurationProblem!]!
}

type KafkaEventHubConfigurationProblem {
  message: String!
  type: KafkaEventHubConfigurationProblemType!
}

enum KafkaEventHubConfigurationProblemType {
  EVENT_HUB_WITH_SAME_NAME_ALREADY_EXISTS,
  INVALID_EVENT_HUB_UUID
}

input ConfigureAzureStorageInput {
  uuid: ID
  name: String!
  description: String
  container: String!
  location: String!
  directory: String
}

union ConfigureAzureStoragePayload =
  AzureStorageConfigured
  | AzureStorageConfigurationFailed

type AzureStorageConfigured {
  storage: AzureStorage!
}

type AzureStorageConfigurationFailed {
  problems: [AzureStorageConfigurationProblem!]!
}

type AzureStorageConfigurationProblem {
  message: String!
  type: AzureStorageConfigurationProblemType!
}

enum AzureStorageConfigurationProblemType {
  """
  The name is already in use by another storage
  """
  STORAGE_WITH_SAME_NAME_ALREADY_EXISTS,
  """
  The uuid doesn't match with the existing storage
  """
  INVALID_STORAGE_UUID
}

input ConfigureGcsStorageInput {
  uuid: ID
  name: String!
  description: String
  bucketName: String!
  bucketPrefix: String
}

union ConfigureGcsStoragePayload =
  GcsStorageConfigured
  | GcsStorageConfigurationFailed

type GcsStorageConfigured {
  storage: GcsStorage!
}

type GcsStorageConfigurationFailed {
  problems: [GcsStorageConfigurationProblem!]!
}

type GcsStorageConfigurationProblem {
  message: String!
  type: GcsStorageConfigurationProblemType!
}

enum GcsStorageConfigurationProblemType {
  """
  The name is already in use by another storage
  """
  STORAGE_WITH_SAME_NAME_ALREADY_EXISTS
  """
  The uuid doesn't match with the existing storage
  """
  INVALID_STORAGE_UUID
}

input ConfigureS3StorageInput {
  uuid: ID
  name: String!
  description: String
  bucketName: String!
  bucketRegion: String!
  bucketPrefix: String
}

union ConfigureS3StoragePayload =
  S3StorageConfigured
  | S3StorageConfigurationFailed

type S3StorageConfigured {
  storage: S3Storage!
}

type S3StorageConfigurationFailed {
  problems: [S3StorageConfigurationProblem!]!
}

type S3StorageConfigurationProblem {
  message: String!
  type: S3StorageConfigurationProblemType!
}

enum S3StorageConfigurationProblemType {
  """
  The name is already in use by another storage
  """
  STORAGE_WITH_SAME_NAME_ALREADY_EXISTS
  """
  The uuid doesn't match with the existing storage
  """
  INVALID_STORAGE_UUID
}


input ConfigureVolumeStorageInput {
  uuid: ID
  name: String!
  description: String
  capacity: String!
}

union ConfigureVolumeStoragePayload =
  VolumeStorageConfigured
  | VolumeStorageConfigurationFailed

type VolumeStorageConfigured {
  storage: VolumeStorage!
}

type VolumeStorageConfigurationFailed {
  problems: [VolumeStorageConfigurationProblem!]!
}

type VolumeStorageConfigurationProblem {
  message: String!
  type: VolumeStorageConfigurationProblemType!
}

enum VolumeStorageConfigurationProblemType {
  """
  The name is already in use by another storage
  """
  STORAGE_WITH_SAME_NAME_ALREADY_EXISTS
  """
  The uuid doesn't match with the existing storage
  """
  INVALID_STORAGE_UUID
}

input ConfigureSaslCredentialsInput {
  name: String!
  uuid: ID
  mechanism: Mechanism!
  username: String!
  password: String!
  useSsl: Boolean!
  sslConf: ConfigureSaslCredentialsSslConfInput
}

input ConfigureSaslCredentialsSslConfInput {
  clientKey: String
  clientKeyPassword: String
  clientCertificate: String
  caCertificate: String
}

union ConfigureSaslCredentialsPayload =
  SaslCredentialsConfigured
  | SaslCredentialsConfigurationFailed

type SaslCredentialsConfigured {
  credentials: SaslCredentials!
}

type SaslCredentialsConfigurationFailed {
  problems: [SaslCredentialsConfigurationProblem!]!
}

type SaslCredentialsConfigurationProblem {
  message: String!
  type: SaslCredentialsConfigurationProblemType!
}

enum SaslCredentialsConfigurationProblemType {
  """
  The name is already in use by other credentials
  """
  CREDENTIALS_WITH_SAME_NAME_ALREADY_EXISTS,
  TYPE_CANNOT_BE_CHANGED
}

input ConfigureMTlsCredentialsInput {
  name: String!
  uuid: ID
  clientKey: String!
  clientKeyPassword: String
  clientCertificate: String!
  caCertificate: String!
}

union ConfigureMTlsCredentialsPayload =
  MTlsCredentialsConfigured
  | MTlsCredentialsConfigurationFailed

type MTlsCredentialsConfigured {
  credentials: MTlsCredentials!
}

type MTlsCredentialsConfigurationFailed {
  problems: [MTlsCredentialsConfigurationProblem!]!
}

type MTlsCredentialsConfigurationProblem {
  message: String!
  type: MTlsCredentialsConfigurationProblemType!
}

enum MTlsCredentialsConfigurationProblemType {
  """
  The name is already in use by other credentials
  """
  CREDENTIALS_WITH_SAME_NAME_ALREADY_EXISTS,
  TYPE_CANNOT_BE_CHANGED
}

input ConfigureAwsCredentialsInput {
  name: String!
  uuid: ID
  accessKeyId: String!
  secretAccessKey: String!
}

union ConfigureAwsCredentialsPayload =
  AwsCredentialsConfigured
  | AwsCredentialsConfigurationFailed

type AwsCredentialsConfigured {
  credentials: AwsCredentials!
}

type AwsCredentialsConfigurationFailed {
  problems: [AwsCredentialsConfigurationProblem!]!
}

type AwsCredentialsConfigurationProblem {
  message: String!
  type: AwsCredentialsConfigurationProblemType!
}

enum AwsCredentialsConfigurationProblemType {
  """
  The name is already in use by other credentials
  """
  CREDENTIALS_WITH_SAME_NAME_ALREADY_EXISTS,
  TYPE_CANNOT_BE_CHANGED
}


input ConfigureAzureCredentialsInput {
  name: String!
  uuid: ID
  sasToken: String!
}

union ConfigureAzureCredentialsPayload =
  AzureCredentialsConfigured
  | AzureCredentialsConfigurationFailed

type AzureCredentialsConfigured {
  credentials: AzureCredentials!
}

type AzureCredentialsConfigurationFailed {
  problems: [AzureCredentialsConfigurationProblem!]!
}

type AzureCredentialsConfigurationProblem {
  message: String!
  type: AzureCredentialsConfigurationProblemType!
}

enum AzureCredentialsConfigurationProblemType {
  """
  The name is already in use by other credentials
  """
  CREDENTIALS_WITH_SAME_NAME_ALREADY_EXISTS,
  TYPE_CANNOT_BE_CHANGED
}

input ConfigureGcpCredentialsInput {
  name: String!
  uuid: ID
  serviceAccountJson: String!
}

union ConfigureGcpCredentialsPayload =
  GcpCredentialsConfigured
  | GcpCredentialsConfigurationFailed

type GcpCredentialsConfigured {
  credentials: GcpCredentials!
}

type GcpCredentialsConfigurationFailed {
  problems: [GcpCredentialsConfigurationProblem!]!
}

type GcpCredentialsConfigurationProblem {
  message: String!
  type: GcpCredentialsConfigurationProblemType!
}

enum GcpCredentialsConfigurationProblemType {
  """
  The name is already in use by other credentials
  """
  CREDENTIALS_WITH_SAME_NAME_ALREADY_EXISTS,
  TYPE_CANNOT_BE_CHANGED
}

input ConfigureBackupInput {
  name: String!
  description: String
  sourceEventHubName: String!
  sourceCredentialsName: String
  sourceAdditionalProperties: [AdditionalPropertyInput!]
  sinkStorageName: String!
  sinkCredentialsName: String
  sinkAdditionalProperties: [AdditionalPropertyInput!]
  segmentRolloverTriggers: SegmentRolloverTriggersInput
  dataRetentionPolicy: DataRetentionPolicyInput
  compression: BackupCompressionInput
  serviceAccountName: String
  resources: ResourceRequirementsInput
}

input AdditionalPropertyInput {
  key: String
  value: String
}

input SegmentRolloverTriggersInput {
  size: String
  timeoutSeconds: Long
}

input DataRetentionPolicyInput {
  delete: DeleteDataRetentionPolicyInput
}

input DeleteDataRetentionPolicyInput {
  after: String
}

input BackupCompressionInput {
  algorithm: BackupCompressionAlgorithm!
  quality: Int
}

union ConfigureBackupPayload =
  BackupConfigured
  | BackupConfigurationFailed

type BackupConfigured {
  backup: Backup!
}

type BackupConfigurationFailed {
  problems: [BackupConfigurationProblem!]!
}

type BackupConfigurationProblem {
  message: String!
  type: BackupConfigurationProblemType!
}

enum BackupConfigurationProblemType {
  SOURCE_EVENT_HUB_NOT_FOUND
  SINK_STORAGE_NOT_FOUND
  SOURCE_CREDENTIALS_NOT_FOUND
  SINK_CREDENTIALS_NOT_FOUND
  SERVICE_ACCOUNT_NOT_FOUND
  BACKUP_WITH_SAME_NAME_ALREADY_EXISTS
}

input ConfigureBackupSourceInput {
  backupName: String!
  eventHubName: String!
  credentialsName: String
  additionalProperties: [AdditionalPropertyInput!]
}

union ConfigureBackupSourcePayload =
  BackupSourceConfigured
  | BackupSourceConfigurationFailed

type BackupSourceConfigured {
  backup: Backup!
}

type BackupSourceConfigurationFailed {
  problems: [BackupSourceConfigurationProblem!]!
}

type BackupSourceConfigurationProblem {
  message: String!
  type: BackupSourceConfigurationProblemType!
}

enum BackupSourceConfigurationProblemType {
  EVENT_HUB_NOT_FOUND
  CREDENTIALS_NOT_FOUND
  BACKUP_NOT_FOUND
}


input ConfigureBackupSinkInput {
  backupName: String!
  storageName: String!
  credentialsName: String
  additionalProperties: [AdditionalPropertyInput!]
}

union ConfigureBackupSinkPayload =
  BackupSinkConfigured
  | BackupSinkConfigurationFailed

type BackupSinkConfigured {
  backup: Backup!
}

type BackupSinkConfigurationFailed {
  problems: [BackupSinkConfigurationProblem!]!
}

type BackupSinkConfigurationProblem {
  message: String!
  type: BackupSinkConfigurationProblemType!
}

enum BackupSinkConfigurationProblemType {
  STORAGE_NOT_FOUND
  CREDENTIALS_NOT_FOUND
  BACKUP_NOT_FOUND
}


input ConfigureBackupCompressionInput {
  backupName: String!
  compression: BackupCompressionInput
}

union ConfigureBackupCompressionPayload =
  BackupCompressionConfigured
  | BackupCompressionConfigurationFailed

type BackupCompressionConfigured {
  backup: Backup!
}

type BackupCompressionConfigurationFailed {
  problems: [BackupCompressionConfigurationProblem!]!
}

type BackupCompressionConfigurationProblem {
  message: String!
  type: BackupCompressionConfigurationProblemType!
}

enum BackupCompressionConfigurationProblemType {
  BACKUP_NOT_FOUND
}

input ConfigureBackupSegmentsInput {
  backupName: String!
  segmentRolloverTriggers: SegmentRolloverTriggersInput
}

union ConfigureBackupSegmentsPayload =
  BackupSegmentsConfigured
  | BackupSegmentsConfigurationFailed

type BackupSegmentsConfigured {
  backup: Backup!
}

type BackupSegmentsConfigurationFailed {
  problems: [BackupSegmentsConfigurationProblem!]!
}

type BackupSegmentsConfigurationProblem {
  message: String!
  type: BackupSegmentsConfigurationProblemType!
}

enum BackupSegmentsConfigurationProblemType {
  BACKUP_NOT_FOUND
}

input ConfigureBackupDataRetentionInput {
  backupName: String!
  dataRetentionPolicy: DataRetentionPolicyInput
}

union ConfigureBackupDataRetentionPayload =
  BackupDataRetentionConfigured
  | BackupDataRetentionConfigurationFailed

type BackupDataRetentionConfigured {
  backup: Backup!
}

type BackupDataRetentionConfigurationFailed {
  problems: [BackupDataRetentionConfigurationProblem!]!
}

type BackupDataRetentionConfigurationProblem {
  message: String!
  type: BackupDataRetentionConfigurationProblemType!
}

enum BackupDataRetentionConfigurationProblemType {
  BACKUP_NOT_FOUND
}

input ConfigureBackupPodSettingsInput {
  backupName: String!
  serviceAccountName: String
  resources: ResourceRequirementsInput
}

union ConfigureBackupPodSettingsPayload =
  BackupPodSettingsConfigured
  | BackupPodSettingsConfigurationFailed

type BackupPodSettingsConfigured {
  backup: Backup!
}

type BackupPodSettingsConfigurationFailed {
  problems: [BackupPodSettingsConfigurationProblem!]!
}

type BackupPodSettingsConfigurationProblem {
  message: String!
  type: BackupPodSettingsConfigurationProblemType!
}

enum BackupPodSettingsConfigurationProblemType {
  BACKUP_NOT_FOUND
  SERVICE_ACCOUNT_NOT_FOUND
}

input TestKafkaConnectionInput {
  bootstrapServers: String!
  properties: [KafkaPropertyInput!]
  authentication: TestKafkaConnectionAuthenticationInput
}

input TestKafkaConnectionAuthenticationInput {
  """
  The name of existing credentials to test with
  """
  credentialsName: String

  """
  SASL credentials properties to test with
  """
  sasl: TestKafkaConnectionSaslAuthenticationInput

  """
  mTLS credentials properties to test with
  """
  mTls: TestKafkaConnectionMTlsAuthenticationInput
}

input TestKafkaConnectionSaslAuthenticationInput {
  mechanism: Mechanism!
  username: String!
  password: String!
  useSsl: Boolean!
  sslConf: TestKafkaConnectionSaslAuthenticationSslInput
}

input TestKafkaConnectionSaslAuthenticationSslInput {
  clientKey: String
  clientKeyPassword: String
  clientCertificate: String
  caCertificate: String
}

input TestKafkaConnectionMTlsAuthenticationInput {
  clientKey: String!
  clientKeyPassword: String
  clientCertificate: String!
  caCertificate: String!
}

union TestConnectionPayload =
  ConnectionTestSucceeded
  | ConnectionTestFailed

type ConnectionTestSucceeded {
  message: String!
}

type ConnectionTestFailed {
  problems: [ConnectionTestFailedProblem!]!
}

type ConnectionTestFailedProblem {
  message: String!
  type: ConnectionTestFailedProblemType!
}

enum ConnectionTestFailedProblemType {
  CREDENTIALS_NOT_FOUND,
  INVALID_CREDENTIALS_TYPE,
  AUTHENTICATION_FAILED,
  CONNECTION_TIME_OUT,
  NO_RESOLVABLE_URLS,
  INVALID_URL,
  INVALID_PORT,
  SSL_HANDSHAKE_FAILED,
  PARSE_CERTIFICATE_FAILED,
  PARSE_PRIVATE_KEY_FAILED,
  SECRET_NOT_FOUND,
  SECRET_VALUE_NOT_FOUND,
  UNKNOWN_ERROR
}


input PauseBackupInput {
  name: String!
}

union PauseBackupPayload = BackupPaused
  | BackupWasAlreadyPaused
  | BackupNotFound

input ResumeBackupInput {
  name: String!
}

union ResumeBackupPayload = BackupResumed
  | BackupWasAlreadyActive
  | BackupNotFound

type BackupPaused {
  backup: Backup!
}

type BackupResumed {
  backup: Backup!
}

type BackupWasAlreadyPaused {
  backup: Backup!
}

type BackupWasAlreadyActive {
  backup: Backup!
}

type BackupNotFound {
  name: String!
}

input DeleteBackupInput {
  name: String!
}

union DeleteBackupPayload = BackupDeleted
  | BackupNotFound

type BackupDeleted {
  backup: Backup
}

input ConfigureRestoreInput {
  id: String,
  description: String,
  sourceBackupName: String
  sourceStorageName: String
  sourceCredentialsName: String
  sourceAdditionalProperties: [AdditionalPropertyInput!]
  sinkEventHubName: String!
  sinkCredentialsName: String
  sinkAdditionalProperties: [AdditionalPropertyInput!]
  topics: [RestoreTopicConfigurationInput!]
  restoreFrom: DateTime
  restoreUntil: DateTime
  legacyOffsetHeader: String
  parallelism: Int
  maxProducers: Int
  serviceAccountName: String
  resources: ResourceRequirementsInput
}

input RestoreTopicConfigurationInput {
  source: String!
  target: String!
  disablePreflightChecks: Boolean
  partitions: [RestorePartitionConfigurationInput!] = []
}

union ConfigureRestorePayload = RestoreConfigured
  | RestoreConfigurationFailed

type RestoreConfigured {
  restore: Restore!
}

type RestoreConfigurationFailed {
  problems: [RestoreConfigurationProblem!]!
}

type RestoreConfigurationProblem {
  message: String!
  type: RestoreConfigurationProblemType!
}

enum RestoreConfigurationProblemType {
  SOURCE_STORAGE_NOT_FOUND
  SINK_EVENT_HUB_NOT_FOUND
  SOURCE_CREDENTIALS_NOT_FOUND
  SINK_CREDENTIALS_NOT_FOUND
  SERVICE_ACCOUNT_NOT_FOUND
  RESTORE_WITH_SAME_ID_ALREADY_EXISTS
  BACKUP_NOT_FOUND
}

input RestorePartitionConfigurationInput {
  number: Int!
  restoreFromOffset: Long
  restoreUntilOffset: Long
}

input ConfigureRestoreSourceInput {
  restoreId: String!,
  backupName: String
  storageName: String
  credentialsName: String
  additionalProperties: [AdditionalPropertyInput!]
}

union ConfigureRestoreSourcePayload = RestoreSourceConfigured
  | RestoreSourceConfigurationFailed

type RestoreSourceConfigured {
  restore: Restore!
}

type RestoreSourceConfigurationFailed {
  problems: [RestoreSourceConfigurationProblem!]!
}

type RestoreSourceConfigurationProblem {
  message: String!
  type: RestoreSourceConfigurationProblemType!
}

enum RestoreSourceConfigurationProblemType {
  RESTORE_NOT_FOUND,
  BACKUP_NOT_FOUND,
  STORAGE_NOT_FOUND,
  CREDENTIALS_NOT_FOUND,
  RESTORE_ALREADY_STARTED
}

input ConfigureRestoreSinkInput {
  restoreId: String!,
  eventHubName: String!
  credentialsName: String
  additionalProperties: [AdditionalPropertyInput!]
}

union ConfigureRestoreSinkPayload = RestoreSinkConfigured
  | RestoreSinkConfigurationFailed

type RestoreSinkConfigured {
  restore: Restore!
}

type RestoreSinkConfigurationFailed {
  problems: [RestoreSinkConfigurationProblem!]!
}

type RestoreSinkConfigurationProblem {
  message: String!
  type: RestoreSinkConfigurationProblemType!
}

enum RestoreSinkConfigurationProblemType {
  RESTORE_NOT_FOUND,
  EVENT_HUB_NOT_FOUND,
  CREDENTIALS_NOT_FOUND,
  RESTORE_ALREADY_STARTED
}

input ConfigureRestoreOptionsInput {
  restoreId: String!
  restoreFrom: DateTime
  restoreUntil: DateTime
  legacyOffsetHeader: String
  parallelism: Int
  maxProducers: Int
}

union ConfigureRestoreOptionsPayload = RestoreOptionsConfigured
  | RestoreOptionsConfigurationFailed

type RestoreOptionsConfigured {
  restore: Restore!
}

type RestoreOptionsConfigurationFailed {
  problems: [RestoreOptionsConfigurationProblem!]!
}

type RestoreOptionsConfigurationProblem {
  message: String!
  type: RestoreOptionsConfigurationProblemType!
}

enum RestoreOptionsConfigurationProblemType {
  RESTORE_NOT_FOUND,
  RESTORE_ALREADY_STARTED
}

input ConfigureRestorePodSettingsInput {
  restoreId: String!
  serviceAccountName: String
  resources: ResourceRequirementsInput
}

union ConfigureRestorePodSettingsPayload = RestorePodSettingsConfigured
  | RestorePodSettingsConfigurationFailed

type RestorePodSettingsConfigured {
  restore: Restore!
}

type RestorePodSettingsConfigurationFailed {
  problems: [RestorePodSettingsConfigurationProblem!]!
}

type RestorePodSettingsConfigurationProblem {
  message: String!
  type: RestorePodSettingsConfigurationProblemType!
}

enum RestorePodSettingsConfigurationProblemType {
  RESTORE_NOT_FOUND,
  SERVICE_ACCOUNT_NOT_FOUND,
  RESTORE_ALREADY_STARTED
}

input StartRestoreInput {
  id: String!
}

union StartRestorePayload = RestoreStarted
  | StartRestoreFailed

type RestoreStarted {
  restore: Restore!
}

type StartRestoreFailed {
  problems: [StartRestoreProblem!]!
}

type StartRestoreProblem {
  message: String!
  type: StartRestoreProblemType!
}

enum StartRestoreProblemType {
  RESTORE_NOT_FOUND,
  RESTORE_ALREADY_STARTED,
  RESTORE_CONFIG_INCOMPLETE,
}

input DeleteRestoreInput {
  id: String!
}

type DeleteRestoreProblem {
  message: String!
  type: DeleteRestoreProblemType!
}

enum DeleteRestoreProblemType {
  RESTORE_NOT_FOUND,
}

type DeleteRestoreFailed {
  problems: [DeleteRestoreProblem!]!
}

union DeleteRestorePayload = RestoreDeleted
  | DeleteRestoreFailed

type RestoreDeleted {
  restore: Restore
}

input ConfigureRestoreTopicsInput {
  """
  The ID of the restore to configure the topics for.
  """
  restoreId: String!

  """
  Configure all topics. Any topic not in this list will be removed from the restore.
  This only works if there is at least one topic in this list.
  For clearing all topics of a restore, use the `topicsToRemove` field.
  """
  topics: [RestoreTopicConfigurationInput!]

  """
  Add these topics to the restore. Any topic already in the restore will be overwritten.
  """
  topicsToAdd: [RestoreTopicConfigurationInput!]

  """
  Remove these topics from the restore. Any topic not in the restore will be ignored.
  """
  topicsToRemove: [String!]
}

union ConfigureRestoreTopicsPayload = RestoreTopicsConfigured
  | ConfigureRestoreTopicsFailed

type RestoreTopicsConfigured {
  restore: Restore!
  added: [String!]!
  removed: [String!]!
}

type ConfigureRestoreTopicsFailed {
  problems: [ConfigureRestoreTopicsProblem!]!
}

type ConfigureRestoreTopicsProblem {
  message: String!
  type: ConfigureRestoreTopicsProblemType!
}

enum ConfigureRestoreTopicsProblemType {
  RESTORE_NOT_FOUND,
  TOPICS_NOT_FOUND,
}


input ConfigureRestoreDescriptionInput {
  restoreId: String!
  description: String
}

union ConfigureRestoreDescriptionPayload = RestoreDescriptionConfigured
  | ConfigureRestoreDescriptionFailed

type RestoreDescriptionConfigured {
  restore: Restore!
}

type ConfigureRestoreDescriptionFailed {
  problems: [ConfigureRestoreDescriptionProblem!]!
}

type ConfigureRestoreDescriptionProblem {
  message: String!
  type: ConfigureRestoreDescriptionProblemType!
}

enum ConfigureRestoreDescriptionProblemType {
  RESTORE_NOT_FOUND,
}

type BackupConnection {
  edges: [BackupEdge!]!
  pageInfo: PageInfo!
}

type BackupEdge {
  cursor: String!
  node: Backup!
}

type RestoreConnection {
  edges: [RestoreEdge!]!
  pageInfo: PageInfo!
}

type RestoreEdge {
  cursor: String!
  node: Restore!
}

type EventHubConnection {
  edges: [EventHubEdge!]!
  pageInfo: PageInfo!
}

type EventHubEdge {
  cursor: String!
  node: EventHub!
}

type CredentialsConnection {
  edges: [CredentialsEdge!]!
  pageInfo: PageInfo!
}

type CredentialsEdge {
  cursor: String!
  node: Credentials!
}

type ServiceAccountConnection {
  edges: [ServiceAccountEdge!]!
  pageInfo: PageInfo!
}

type ServiceAccountEdge {
  cursor: String!
  node: ServiceAccount!
}

type EventHubTopicConnection {
  edges: [EventHubTopicEdge!]!
  pageInfo: PageInfo!
}

type EventHubTopicEdge {
  cursor: String!
  node: EventHubTopic!
}

type StorageConnection {
  edges: [StorageEdge!]!
  pageInfo: PageInfo!
}

type StorageEdge {
  cursor: String!
  node: Storage!
}

input ConfigureBackupTopicsInput {
  """
  The name of the backup to configure the topics for.
  """
  backupName: String!

  """
  Configure all topics. Any topic not in this list will be removed from the backup.
  This only works if there is at least one topic in this list.
  For clearing all topics of a backup, use the `topicsToRemove` field.
  """
  topics: [String]

  """
  Add these topics to the backup. Any topic already in the backup will be ignored.
  """
  topicsToAdd: [String!]

  """
  Remove these topics from the backup. Any topic not in the backup will be ignored.
  """
  topicsToRemove: [String!]

  """
  Set to true to immediately enable backup for the topics that will be added.
  """
  enable: Boolean!
}

union ConfigureBackupTopicsPayload = BackupTopicsConfigured
  | ConfigureBackupTopicsFailed

type BackupTopicsConfigured {
  backup: Backup!
  added: [String!]!
  removed: [String!]!
}

type ConfigureBackupTopicsFailed {
  problems: [ConfigureBackupTopicsProblem!]!
}

type ConfigureBackupTopicsProblem {
  message: String!
  type: ConfigureBackupTopicsProblemType!
  topics: [String!]
}

enum ConfigureBackupTopicsProblemType {
  BACKUP_NOT_FOUND,
  SOURCE_EVENT_HUB_NOT_FOUND,
  SOURCE_EVENT_HUB_UNREACHABLE,
  SOURCE_CREDENTIALS_NOT_FOUND,
  INVALID_CREDENTIALS_TYPE,
  INVALID_CREDENTIALS_SECRET,
  TOPICS_NOT_FOUND,
}


input ConfigureBackupDescriptionInput {
  backupName: String!
  description: String
}

union ConfigureBackupDescriptionPayload = BackupDescriptionConfigured
  | ConfigureBackupDescriptionFailed

type BackupDescriptionConfigured {
  backup: Backup!
}

type ConfigureBackupDescriptionFailed {
  problems: [ConfigureBackupDescriptionProblem!]!
}

type ConfigureBackupDescriptionProblem {
  message: String!
  type: ConfigureBackupDescriptionProblemType!
}

enum ConfigureBackupDescriptionProblemType {
  BACKUP_NOT_FOUND,
}

input EnableBackupStreamsInput {
  backupName: String!
  topics: [String!]!
}

type BackupStreamsEnabled {
  backup: Backup!
  enabled: [BackupStream!]!
}

type EnableBackupStreamsFailed {
  problems: [EnableBackupStreamsProblem!]!
}

type EnableBackupStreamsProblem {
  message: String!
  type: EnableBackupStreamsProblemType!
}

enum EnableBackupStreamsProblemType {
  TOPICS_NOT_FOUND,
  BACKUP_NOT_FOUND,
}

union EnableBackupStreamsPayload = BackupStreamsEnabled | EnableBackupStreamsFailed

input PauseBackupStreamsInput {
  backupName: String!
  topics: [String!]!
}

type BackupStreamsPaused {
  backup: Backup!
  paused: [BackupStream!]!
}

type PauseBackupStreamsFailed {
  problems: [PauseBackupStreamsProblem!]!
}

type PauseBackupStreamsProblem {
  message: String!
  type: PauseBackupStreamsProblemType!
}

enum PauseBackupStreamsProblemType {
  STREAM_NOT_FOUND,
  BACKUP_NOT_FOUND
}

union PauseBackupStreamsPayload = BackupStreamsPaused | PauseBackupStreamsFailed

input IgnoreTopicsInput {
  backupName: String!
  topics: [String!]!
}

type TopicsIgnored {
  backup: Backup!
  ignored: [String!]!
}

type IgnoreTopicsFailed {
  problems: [IgnoreTopicsProblem!]!
}

type IgnoreTopicsProblem {
  message: String!
  type: IgnoreTopicsProblemType!
  topics: [String!]
}

enum IgnoreTopicsProblemType {
  BACKUP_NOT_FOUND,
  TOPICS_ARE_STREAMING
}

union IgnoreTopicsPayload = TopicsIgnored | IgnoreTopicsFailed

type Mutation {
  configureKafkaEventHub(input: ConfigureKafkaEventHubInput!): ConfigureKafkaEventHubPayload

  testKafkaConnection(input: TestKafkaConnectionInput!): TestConnectionPayload

  configureAzureStorage(input: ConfigureAzureStorageInput!): ConfigureAzureStoragePayload
  configureGcsStorage(input: ConfigureGcsStorageInput!): ConfigureGcsStoragePayload
  configureS3Storage(input: ConfigureS3StorageInput!): ConfigureS3StoragePayload
  configureVolumeStorage(input: ConfigureVolumeStorageInput!): ConfigureVolumeStoragePayload

  configureAwsCredentials(input: ConfigureAwsCredentialsInput!): ConfigureAwsCredentialsPayload
  configureAzureCredentials(input: ConfigureAzureCredentialsInput!): ConfigureAzureCredentialsPayload
  configureGcpCredentials(input: ConfigureGcpCredentialsInput!): ConfigureGcpCredentialsPayload
  configureSaslCredentials(input: ConfigureSaslCredentialsInput!): ConfigureSaslCredentialsPayload
  configureMTlsCredentials(input: ConfigureMTlsCredentialsInput!): ConfigureMTlsCredentialsPayload

  ignoreTopics(input: IgnoreTopicsInput!): IgnoreTopicsPayload

  enableBackupStreams(input: EnableBackupStreamsInput!): EnableBackupStreamsPayload
  pauseBackupStreams(input: PauseBackupStreamsInput!): PauseBackupStreamsPayload

  configureBackup(input: ConfigureBackupInput!): ConfigureBackupPayload
  configureBackupTopics(input: ConfigureBackupTopicsInput!): ConfigureBackupTopicsPayload
  configureBackupDescription(input: ConfigureBackupDescriptionInput!): ConfigureBackupDescriptionPayload
  configureBackupSource(input: ConfigureBackupSourceInput!): ConfigureBackupSourcePayload
  configureBackupSink(input: ConfigureBackupSinkInput!): ConfigureBackupSinkPayload
  configureBackupCompression(input: ConfigureBackupCompressionInput!): ConfigureBackupCompressionPayload
  configureBackupSegments(input: ConfigureBackupSegmentsInput!): ConfigureBackupSegmentsPayload
  configureBackupDataRetention(input: ConfigureBackupDataRetentionInput!): ConfigureBackupDataRetentionPayload
  configureBackupPodSettings(input: ConfigureBackupPodSettingsInput!): ConfigureBackupPodSettingsPayload
  pauseBackup(input: PauseBackupInput!): PauseBackupPayload
  resumeBackup(input: ResumeBackupInput!): ResumeBackupPayload
  deleteBackup(input: DeleteBackupInput!): DeleteBackupPayload

  configureRestore(input: ConfigureRestoreInput!): ConfigureRestorePayload
  configureRestoreTopics(input: ConfigureRestoreTopicsInput!): ConfigureRestoreTopicsPayload
  configureRestoreDescription(input: ConfigureRestoreDescriptionInput!): ConfigureRestoreDescriptionPayload
  configureRestoreSource(input: ConfigureRestoreSourceInput!): ConfigureRestoreSourcePayload
  configureRestoreSink(input: ConfigureRestoreSinkInput!): ConfigureRestoreSinkPayload
  configureRestoreOptions(input: ConfigureRestoreOptionsInput!): ConfigureRestoreOptionsPayload
  configureRestorePodSettings(input: ConfigureRestorePodSettingsInput!): ConfigureRestorePodSettingsPayload
  startRestore(input: StartRestoreInput!): StartRestorePayload
  deleteRestore(input: DeleteRestoreInput!): DeleteRestorePayload
}

type Query {
  getBackupByName(name: String!) : Backup
  getBackupMetrics(name: String!) : BackupMetricsPayload
  getBackups(first: Int = 10, after: String): BackupConnection

  getRestoreById(id: String!) : Restore
  getRestores(first: Int = 10, after: String): RestoreConnection
  getRestoreMetrics(id: String!) : RestoreMetricsPayload

  getEventHubByName(name: String!) : EventHub
  getEventHubs(first: Int = 10, after: String): EventHubConnection
  getEventHubTopics(eventHubName: String!, credentialsName: String, skipCache: Boolean = false, first: Int = 100, after: String): EventHubTopicConnection

  getStorages(first: Int = 10, after: String): StorageConnection

  getCredentials(first: Int = 100, after: String): CredentialsConnection
  getEventHubCredentials(eventHubType: String, first: Int = 100, after: String): CredentialsConnection
  getStorageCredentials(storageType: String, first: Int = 100, after: String): CredentialsConnection

  getServiceAccounts(first: Int = 100, after: String): ServiceAccountConnection

}

type PageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

type ResourceRequirements {
  requests: ResourceRequirementSettings
  limits: ResourceRequirementSettings
}

type ResourceRequirementSettings {
  cpu: String
  memory: String
}

input ResourceRequirementsInput {
  requests: ResourceRequirementSettingsInput
  limits: ResourceRequirementSettingsInput
}

input ResourceRequirementSettingsInput {
  cpu: String
  memory: String
}


union BackupMetricsPayload = BackupMetrics | BackupMetricsHeartbeat | BackupMetricsFailed

type BackupMetrics {
  ingestion: Ingestion
  totalCompressedSize: Long
  totalUncompressedSize: Long
  topicStatuses: [TopicStatus!]
  topicMessageCounts: [TopicMessageCount!]
  topicCompressedSizes: [TopicMessageSize!]
  topicUncompressedSizes: [TopicMessageSize!]
}

type TopicMessageCount {
  topicName: String!
  count: Long!
}

type TopicMessageSize {
  topicName: String!
  size: Long!
}

type TopicStatus {
  topicName: String!
  status: TopicStatuses!
}

enum TopicStatuses {
  CREATED
  RUNNING
  PAUSED
  BACKOFF
  DONE
  FAILED
}

type TopicIngestionRate {
  topicName: String!
  rate: Ingestion!
}

type Ingestion {
  bytesPerSecond: Long
}

type BackupMetricsHeartbeat {
  message: String
}

type BackupMetricsFailed {
  problems: [BackupMetricsProblem!]!
}

type BackupMetricsProblem {
  message: String!
  type: BackupMetricsProblemType!
}

enum BackupMetricsProblemType {
  BACKUP_NOT_FOUND,
}

input BackupMetricsSubscriptionInput {

  """
  The name of the backup to get the metrics for.
  """
  backupName: String!

  """
  The interval to receive the metrics.
  Note that metrics themselves are not guaranteed to be updated at this interval.
  This is just the interval at which the client will receive metrics, irrelevant of the actual query interval.

  Minimum value is defined by the server property `kannika.graphql.subscriptions.minInterval`, which is 1s by default.
  Maximum value is defined by the server property `kannika.graphql.subscriptions.maxInterval`, which is 60s by default.
  Default value is defined by the server property `kannika.graphql.subscriptions.defaultInterval`, which is 10s by default.
  """
  interval: Duration

}


union RestoreMetricsPayload = RestoreMetrics | RestoreMetricsHeartbeat | RestoreMetricsFailed

type RestoreMetrics {
  topicStatuses: [TopicStatus!]
  topicRestoredSizes: [TopicMessageSize!]
  topicToRestoreSizes: [TopicMessageSize!]
  topicMessagesToRestoreCounts: [TopicMessageCount!]
  topicIngestionRates: [TopicIngestionRate!]
}

type RestoreMetricsHeartbeat {
  message: String
}

type RestoreMetricsFailed {
  problems: [RestoreMetricsProblem!]!
}

type RestoreMetricsProblem {
  message: String!
  type: RestoreMetricsProblemType!
}

enum RestoreMetricsProblemType {
  RESTORE_NOT_FOUND,
}

input RestoreMetricsSubscriptionInput {

  """
  The id of the restore to get the metrics for.
  """
  restoreId: String!

  """
  The interval to receive the metrics.
  Note that metrics themselves are not guaranteed to be updated at this interval.
  This is just the interval at which the client will receive metrics, irrelevant of the actual query interval.

  Minimum value is defined by the server property `kannika.graphql.subscriptions.minInterval`, which is 1s by default.
  Maximum value is defined by the server property `kannika.graphql.subscriptions.maxInterval`, which is 60s by default.
  Default value is defined by the server property `kannika.graphql.subscriptions.defaultInterval`, which is 10s by default.
  """
  interval: Duration

}

type Subscription {
  backupMetrics(input: BackupMetricsSubscriptionInput!): BackupMetricsPayload
  restoreMetrics(input: RestoreMetricsSubscriptionInput!): RestoreMetricsPayload
}

directive @todo(remark: String = "TODO") on FIELD_DEFINITION