schema.graphql

# source: http://127.0.0.1:8081/admin/api
# timestamp: Thu Aug 22 2024 19:23:56 GMT+0300 (Moscow Standard Time)

"""Custom scalar specification."""
directive @specifiedBy(
  """Scalar specification URL."""
  url: String!
) on SCALAR

"""Cluster management"""
type Apicluster {
  """Some information about current server"""
  self: ServerShortInfo

  """Clusterwide DDL schema"""
  schema: DDLSchema!

  """Get current failover state. (Deprecated since v2.0.2-2)"""
  failover: Boolean!

  """Whether it is reasonble to call bootstrap_vshard mutation"""
  can_bootstrap_vshard: Boolean!
  auth_params: UserManagementAPI!

  """List of pages to be hidden in WebUI"""
  webui_blacklist: [String!]

  """List issues in cluster"""
  issues: [Issue!]

  """Show suggestions to resolve operation problems"""
  suggestions: Suggestions

  """Get state provider status."""
  failover_state_provider_status: [StateProviderStatus]!

  """List authorized users"""
  users(
    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    username: String
  ): [User!]

  """compression info about cluster"""
  cluster_compression: ClusterCompressionInfo!

  """Get list of all registered roles and their dependencies."""
  known_roles: [Role!]!

  """Virtual buckets count in cluster"""
  vshard_bucket_count: Int!

  """Get automatic failover configuration."""
  failover_params: FailoverAPI!
  vshard_groups: [VshardGroup!]!

  """Validate config"""
  validate_config(sections: [ConfigSectionInput]): ValidateConfigResult!

  """Get list of known vshard storage groups."""
  vshard_known_groups: [String!]!

  """Get cluster config sections"""
  config(sections: [String!]): [ConfigSection]!
}

"""Compression info of all cluster instances"""
type ClusterCompressionInfo {
  """cluster compression info"""
  compression_info: [InstanceCompressionInfo!]!
}

"""A section of clusterwide configuration"""
type ConfigSection {
  filename: String!
  content: String!
}

"""A section of clusterwide configuration"""
input ConfigSectionInput {
  filename: String!
  content: String
}

"""Result of schema validation"""
type DDLCheckResult {
  """Error details if validation fails, null otherwise"""
  error: String
}

"""The schema"""
type DDLSchema {
  as_yaml: String!
}

"""
A suggestion to disable malfunctioning servers in order to restore the quorum
"""
type DisableServerSuggestion {
  uuid: String!
}

"""Parameters for editing a replicaset"""
input EditReplicasetInput {
  weight: Float
  all_rw: Boolean
  failover_priority: [String!]
  vshard_group: String
  join_servers: [JoinServerInput]
  alias: String
  uuid: String
  roles: [String!]
  rebalancer: Boolean
}

"""Parameters for editing existing server"""
input EditServerInput {
  electable: Boolean
  zone: String
  uri: String
  labels: [LabelInput]
  disabled: Boolean
  uuid: String!
  expelled: Boolean
  rebalancer: Boolean
}

type EditTopologyResult {
  replicasets: [Replicaset]!
  servers: [Server]!
}

type Error {
  stack: String
  class_name: String
  message: String!
}

"""Failover parameters managent"""
type FailoverAPI {
  fencing_enabled: Boolean!
  failover_timeout: Float!
  autoreturn_delay: Float!
  fencing_pause: Float!
  leader_autoreturn: Boolean!
  check_cookie_hash: Boolean!
  tarantool_params: FailoverStateProviderCfgTarantool

  """Supported modes are "disabled", "eventual", "stateful" or "raft"."""
  mode: String!
  fencing_timeout: Float!

  """
  Type of external storage for the stateful failover mode. Supported types are "tarantool" and "etcd2".
  """
  state_provider: String
  etcd2_params: FailoverStateProviderCfgEtcd2
}

"""State provider configuration (etcd-v2)"""
type FailoverStateProviderCfgEtcd2 {
  password: String!
  lock_delay: Float!
  endpoints: [String!]!
  username: String!
  prefix: String!
}

"""State provider configuration (etcd-v2)"""
input FailoverStateProviderCfgInputEtcd2 {
  password: String
  lock_delay: Float
  endpoints: [String!]
  username: String
  prefix: String
}

"""State provider configuration (Tarantool)"""
input FailoverStateProviderCfgInputTarantool {
  uri: String!
  password: String!
}

"""State provider configuration (Tarantool)"""
type FailoverStateProviderCfgTarantool {
  uri: String!
  password: String!
}

"""Information about single field compression rate possibility"""
type FieldCompressionInfo {
  """compression percentage"""
  compression_percentage: Int!

  """field name"""
  field_name: String!

  """compression time"""
  compression_time: Int!
}

"""
A suggestion to reapply configuration forcefully. There may be several reasons
to do that: configuration checksum mismatch (config_mismatch); the locking of
tho-phase commit (config_locked); an error during previous config update
(operation_error).
"""
type ForceApplySuggestion {
  config_mismatch: Boolean!
  config_locked: Boolean!
  uuid: String!
  operation_error: Boolean!
}

"""Combined info of all user spaces in the instance"""
type InstanceCompressionInfo {
  """instance id"""
  instance_id: String!

  """instance compression info"""
  instance_compression_info: [SpaceCompressionInfo!]!
}

type Issue {
  level: String!
  instance_uuid: String
  replicaset_uuid: String
  message: String!
  topic: String!
}

"""Parameters for joining a new server"""
input JoinServerInput {
  uri: String!
  labels: [LabelInput]
  rebalancer: Boolean
  uuid: String
  zone: String
}

"""Cluster server label"""
type Label {
  name: String!
  value: String!
}

"""Cluster server label"""
input LabelInput {
  name: String!
  value: String!
}

"""
The `Long` scalar type represents non-fractional signed whole numeric values.
Long can represent values from -(2^52) to 2^52 - 1, inclusive.
"""
scalar Long

type Mutation {
  """Cluster management"""
  cluster: MutationApicluster

  """Deprecated. Use `cluster{edit_topology()}` instead."""
  edit_server(
    uuid: String!

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    uri: String
    labels: [LabelInput]
  ): Boolean
  probe_server(uri: String!): Boolean

  """Deprecated. Use `cluster{edit_topology()}` instead."""
  edit_replicaset(
    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    weight: Float
    master: [String!]

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    alias: String
    roles: [String!]
    uuid: String!

    """The `Boolean` scalar type represents `true` or `false`."""
    all_rw: Boolean

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    vshard_group: String
  ): Boolean

  """Deprecated. Use `cluster{edit_topology()}` instead."""
  join_server(
    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    instance_uuid: String

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    timeout: Float

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    zone: String
    uri: String!

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    vshard_group: String
    labels: [LabelInput]

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    replicaset_alias: String

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    replicaset_uuid: String
    roles: [String!]

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    replicaset_weight: Float
  ): Boolean
  bootstrap_vshard: Boolean

  """Deprecated. Use `cluster{edit_topology()}` instead."""
  expel_server(uuid: String!): Boolean
}

"""Cluster management"""
type MutationApicluster {
  """Applies DDL schema on cluster"""
  schema(as_yaml: String!): DDLSchema!

  """
  Enable or disable automatic failover. Returns new state. (Deprecated since v2.0.2-2)
  """
  failover(enabled: Boolean!): Boolean!

  """Configure automatic failover."""
  failover_params(
    """The `Boolean` scalar type represents `true` or `false`."""
    fencing_enabled: Boolean

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    failover_timeout: Float

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    autoreturn_delay: Float

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    fencing_pause: Float

    """The `Boolean` scalar type represents `true` or `false`."""
    leader_autoreturn: Boolean

    """The `Boolean` scalar type represents `true` or `false`."""
    check_cookie_hash: Boolean

    """State provider configuration (Tarantool)"""
    tarantool_params: FailoverStateProviderCfgInputTarantool

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    mode: String

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    fencing_timeout: Float

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    state_provider: String

    """State provider configuration (etcd-v2)"""
    etcd2_params: FailoverStateProviderCfgInputEtcd2
  ): FailoverAPI!

  """Pause failover"""
  failover_pause: Boolean!

  """Enable listed servers by uuid"""
  enable_servers(uuids: [String!]): [Server]

  """Reapplies config on the specified nodes"""
  config_force_reapply(uuids: [String]): Boolean!

  """Restart replication on servers specified by uuid"""
  restart_replication(uuids: [String!]): Boolean

  """Remove user"""
  remove_user(username: String!): User

  """Checks that the schema can be applied on the cluster"""
  check_schema(as_yaml: String!): DDLCheckResult!

  """Disable listed servers by uuid"""
  disable_servers(uuids: [String!]): [Server]

  """Create a new user"""
  add_user(
    password: String!
    username: String!

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    fullname: String

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    email: String
  ): User
  auth_params(
    """
    The `Long` scalar type represents non-fractional signed whole numeric
    values. Long can represent values from -(2^52) to 2^52 - 1, inclusive.
    """
    cookie_max_age: Long

    """The `Boolean` scalar type represents `true` or `false`."""
    enabled: Boolean

    """
    The `Long` scalar type represents non-fractional signed whole numeric
    values. Long can represent values from -(2^52) to 2^52 - 1, inclusive.
    """
    cookie_renew_age: Long
  ): UserManagementAPI!

  """Resume failover after pausing"""
  failover_resume: Boolean!

  """Edit an existing user"""
  edit_user(
    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    password: String
    username: String!

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    fullname: String

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    email: String
  ): User

  """Edit cluster topology"""
  edit_topology(replicasets: [EditReplicasetInput], servers: [EditServerInput]): EditTopologyResult

  """Promote the instance to the leader of replicaset"""
  failover_promote(
    instance_uuid: String!

    """The `Boolean` scalar type represents `true` or `false`."""
    force_inconsistency: Boolean

    """The `Boolean` scalar type represents `true` or `false`."""
    skip_error_on_change: Boolean
    replicaset_uuid: String!
  ): Boolean!
  edit_vshard_options(
    """
    The `Int` scalar type represents non-fractional signed whole numeric values.
    Int can represent values from -(2^31) to 2^31 - 1, inclusive.
    """
    rebalancer_max_receiving: Int

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    collect_bucket_garbage_interval: Float

    """The `Boolean` scalar type represents `true` or `false`."""
    collect_lua_garbage: Boolean

    """
    The `Long` scalar type represents non-fractional signed whole numeric
    values. Long can represent values from -(2^52) to 2^52 - 1, inclusive.
    """
    sched_ref_quota: Long

    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    rebalancer_mode: String

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    sync_timeout: Float

    """
    The `Int` scalar type represents non-fractional signed whole numeric values.
    Int can represent values from -(2^31) to 2^31 - 1, inclusive.
    """
    rebalancer_max_sending: Int

    """
    The `Float` scalar type represents signed double-precision fractional values as specified by IEEE 754.
    """
    rebalancer_disbalance_threshold: Float
    name: String!

    """
    The `Long` scalar type represents non-fractional signed whole numeric
    values. Long can represent values from -(2^52) to 2^52 - 1, inclusive.
    """
    sched_move_quota: Long
  ): VshardGroup!

  """Applies updated config on the cluster"""
  config(sections: [ConfigSectionInput]): [ConfigSection]!
}

type Query {
  """Cluster management"""
  cluster: Apicluster
  servers(
    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    uuid: String
  ): [Server]
  replicasets(
    """
    The `String` scalar type represents textual data, represented as UTF-8
    character sequences. The String type is most often used by GraphQL to
    represent free-form human-readable text.
    """
    uuid: String
  ): [Replicaset]
}

"""
A suggestion to reconfigure cluster topology because  one or more servers were restarted with a new advertise uri
"""
type RefineUriSuggestion {
  uri_new: String!
  uuid: String!
  uri_old: String!
}

"""Group of servers replicating the same data"""
type Replicaset {
  """
  Vshard replica set weight. Null for replica sets with vshard-storage role disabled.
  """
  weight: Float

  """The leader according to the configuration."""
  master: Server!

  """
  The replica set health. It is "healthy" if all instances have status "healthy". Otherwise "unhealthy".
  """
  status: String!

  """The replica set uuid"""
  uuid: String!

  """All instances in replica set are rw"""
  all_rw: Boolean!

  """
  Vshard storage group name. Meaningful only when multiple vshard groups are configured.
  """
  vshard_group: String

  """The replica set alias"""
  alias: String!

  """The role set enabled on every instance in the replica set"""
  roles: [String!]

  """
  The active leader. It may differ from "master" if failover is enabled and configured leader isn't healthy.
  """
  active_master: Server!

  """Servers in the replica set."""
  servers: [Server!]!

  """Is the rebalancer enabled for the replica set."""
  rebalancer: Boolean
}

"""Statistics for an instance in the replica set."""
type ReplicaStatus {
  downstream_status: String
  id: Int
  upstream_peer: String
  upstream_idle: Float
  upstream_message: String
  lsn: Long
  upstream_status: String
  upstream_lag: Float
  uuid: String!
  downstream_message: String
  downstream_lag: Float
}

"""A suggestion to restart malfunctioning replications"""
type RestartReplicationSuggestion {
  uuid: String!
}

type Role {
  dependencies: [String!]
  implies_storage: Boolean!
  name: String!
  implies_router: Boolean!
}

"""A server participating in tarantool cluster"""
type Server {
  statistics: ServerStat
  boxinfo: ServerInfo
  replicaset: Replicaset
  disabled: Boolean

  """
  Difference between remote clock and the current one. Obtained from the
  membership module (SWIM protocol). Positive values mean remote clock are ahead
  of local, and vice versa. In seconds.
  """
  clock_delta: Float
  message: String!
  zone: String

  """Is allowed to elect this instance as leader"""
  electable: Boolean
  status: String!
  uri: String!
  labels: [Label]
  uuid: String!
  alias: String

  """Failover priority within the replica set"""
  priority: Int

  """Is rebalancer enabled for this instance"""
  rebalancer: Boolean
}

"""Server information and configuration."""
type ServerInfo {
  membership: ServerInfoMembership!
  cartridge: ServerInfoCartridge!
  replication: ServerInfoReplication!
  storage: ServerInfoStorage!
  network: ServerInfoNetwork!
  general: ServerInfoGeneral!
  vshard_storage: ServerInfoVshardStorage

  """List of vshard router parameters"""
  vshard_router: [VshardRouter]
}

type ServerInfoCartridge {
  """Error details if instance is in failure state"""
  error: Error

  """VShard version"""
  vshard_version: String

  """Cartridge version"""
  version: String!

  """Current instance state"""
  state: String!

  """DDL version"""
  ddl_version: String

  """List of rocks and their versions"""
  rocks: [String]
}

type ServerInfoGeneral {
  """The Tarantool version"""
  version: String!

  """HTTP webui prefix"""
  webui_prefix: String

  """Current read-only state"""
  ro: Boolean!

  """A directory where vinyl files or subdirectories will be stored"""
  vinyl_dir: String

  """The process ID"""
  pid: Int!

  """HTTP port"""
  http_port: Int

  """The Application version"""
  app_version: String

  """A directory where memtx stores snapshot (.snap) files"""
  memtx_dir: String

  """The binary protocol URI"""
  listen: String

  """A globally unique identifier of the instance"""
  instance_uuid: String!

  """State after Raft leader election"""
  election_state: String

  """The number of seconds since the instance started"""
  uptime: Float!

  """
  The maximum number of threads to use during execution of certain internal
  processes (currently socket.getaddrinfo() and coio_call())
  """
  worker_pool_threads: Int

  """The UUID of the replica set"""
  replicaset_uuid: String!

  """A directory where write-ahead log (.xlog) files are stored"""
  wal_dir: String

  """Current working directory of a process"""
  work_dir: String

  """Current read-only state reason"""
  ro_reason: String

  """Leader idle value in seconds"""
  election_leader_idle: Float

  """Id of current queue owner"""
  synchro_queue_owner: Int!

  """Instance election mode"""
  election_mode: String!

  """HTTP host"""
  http_host: String
}

type ServerInfoMembership {
  """Direct ping period"""
  PROTOCOL_PERIOD_SECONDS: Float

  """Number of members to ping a suspect indirectly"""
  NUM_FAILURE_DETECTION_SUBGROUPS: Int

  """
  Value incremented every time the instance became a suspect, dead, or updates its payload
  """
  incarnation: Int

  """Status of the instance"""
  status: String

  """ACK message wait time"""
  ACK_TIMEOUT_SECONDS: Float

  """Timeout to mark a suspect dead"""
  SUSPECT_TIMEOUT_SECONDS: Float

  """Anti-entropy synchronization period"""
  ANTI_ENTROPY_PERIOD_SECONDS: Float
}

type ServerInfoNetwork {
  """
  The server will sleep for `io_collect_interval` seconds between iterations of the event loop
  """
  io_collect_interval: Float

  """The size of the read-ahead buffer associated with a client connection"""
  readahead: Long

  """
  Since if the net_msg_max limit is reached, we will stop processing incoming requests
  """
  net_msg_max: Long
}

type ServerInfoReplication {
  """
  Maximal time box.cfg() may wait for connections to all configured replicas to
  be established. If box.cfg() fails to connect to all replicas within the
  timeout, it will either leave the instance in the orphan mode (recovery) or
  fail (bootstrap, reconfiguration).
  """
  replication_connect_timeout: Float

  """
  Allows automatic skip of conflicting rows in replication based on box.cfg configuration option.
  """
  replication_skip_conflict: Boolean

  """
  Switch applier from "sync" to "follow" as soon as the replication lag is less than the value of the following variable.
  """
  replication_sync_lag: Float

  """The vector clock of replication log sequence numbers"""
  vclock: [Long]

  """
  Wait for the given period of time before trying to reconnect to a master.
  """
  replication_timeout: Float

  """
  Minimal number of replicas to sync for this instance to switch to the write
  mode. If set to REPLICATION_CONNECT_QUORUM_ALL, wait for all configured masters.
  """
  replication_connect_quorum: Int

  """
  Statistics for all instances in the replica set in regard to the current instance
  """
  replication_info: [ReplicaStatus]

  """How many threads to use for decoding incoming replication stream."""
  replication_threads: Float

  """
  Max time to wait for appliers to synchronize before entering the orphan mode.
  """
  replication_sync_timeout: Float
}

type ServerInfoStorage {
  """The maximal size of a single write-ahead log file"""
  wal_max_size: Long

  """The maximal number of runs per level in vinyl LSM tree"""
  vinyl_run_count_per_level: Int

  """
  Deprecated. See "wal_max_size"
  """
  rows_per_wal: Long

  """Limit the pace at which replica submits new transactions to WAL"""
  wal_queue_max_size: Long

  """The cache size for the vinyl storage engine"""
  vinyl_cache: Long

  """The default maximum range size for a vinyl index, in bytes"""
  vinyl_range_size: Long

  """Timeout between compactions"""
  vinyl_timeout: Float

  """
  Size of the smallest allocation unit, in bytes. It can be tuned up if most of the tuples are not so small.
  """
  memtx_min_tuple_size: Long

  """Size of the largest allocation unit, for the vinyl storage engine"""
  vinyl_max_tuple_size: Long

  """Page size. Page is a read/write unit for vinyl disk operations"""
  vinyl_page_size: Long

  """
  Size of the largest allocation unit, in bytes. It can be tuned up if it is necessary to store large tuples.
  """
  memtx_max_tuple_size: Long

  """
  Option to prevent early cleanup of `*.xlog` files which are needed by replicas and lead to `XlogGapError`
  """
  wal_cleanup_delay: Long

  """
  Specify fiber-WAL-disk synchronization mode as: "none": write-ahead log is not
  maintained; "write": fibers wait for their data to be written to the
  write-ahead log; "fsync": fibers wait for their data, fsync follows each write.
  """
  wal_mode: String

  """
  How much memory Memtx engine allocates to actually store tuples, in bytes.
  """
  memtx_memory: Long

  """
  Allows to select the appropriate allocator for memtx tuples if necessary.
  """
  memtx_allocator: String

  """
  Warning in the WAL log if a transaction waits for quota for more than `too_long_threshold` seconds
  """
  too_long_threshold: Float

  """Bloom filter false positive rate"""
  vinyl_bloom_fpr: Float

  """The maximum number of in-memory bytes that vinyl uses"""
  vinyl_memory: Long

  """Ratio between the sizes of different levels in the LSM tree"""
  vinyl_run_size_ratio: Float

  """
  The maximum number of write threads that vinyl can use for some concurrent operations, such as I/O and compression
  """
  vinyl_write_threads: Int

  """
  The maximum number of read threads that vinyl can use for some concurrent operations, such as I/O and compression
  """
  vinyl_read_threads: Int

  """Background fiber restart delay to follow xlog changes."""
  wal_dir_rescan_delay: Float
}

type ServerInfoVshardStorage {
  """Total number of buckets on the storage"""
  buckets_total: Int

  """The number of buckets that are sending at this time"""
  buckets_sending: Int

  """Vshard group"""
  vshard_group: String

  """The number of buckets that are receiving at this time"""
  buckets_receiving: Int

  """The number of active buckets on the storage"""
  buckets_active: Int

  """The number of pinned buckets on the storage"""
  buckets_pinned: Int

  """The number of buckets that are waiting to be collected by GC"""
  buckets_garbage: Int

  """Whether the rebalancer is enabled"""
  rebalancer_enabled: Boolean
}

"""A short server information"""
type ServerShortInfo {
  error: String
  demo_uri: String
  uri: String!
  alias: String
  state: String
  instance_name: String
  app_name: String
  uuid: String
}

"""
Slab allocator statistics. This can be used to monitor the total memory usage (in bytes) and memory fragmentation.
"""
type ServerStat {
  """
  The total amount of memory (including allocated, but currently free slabs) used only for tuples, no indexes
  """
  items_size: Long!

  """Number of buckets active on the storage"""
  vshard_buckets_count: Int

  """
  The maximum amount of memory that the slab allocator can use for both tuples
  and indexes (as configured in the memtx_memory parameter)
  """
  quota_size: Long!

  """
  = items_used / slab_count * slab_size (these are slabs used only for tuples, no indexes)
  """
  items_used_ratio: String!

  """The amount of memory that is already distributed to the slab allocator"""
  quota_used: Long!

  """= arena_used / arena_size"""
  arena_used_ratio: String!

  """
  The efficient amount of memory (omitting allocated, but currently free slabs) used only for tuples, no indexes
  """
  items_used: Long!

  """= quota_used / quota_size"""
  quota_used_ratio: String!

  """
  The total memory used for tuples and indexes together (including allocated, but currently free slabs)
  """
  arena_size: Long!

  """
  The efficient memory used for storing tuples and indexes together (omitting allocated, but currently free slabs)
  """
  arena_used: Long!
}

"""List of fields compression info"""
type SpaceCompressionInfo {
  """list of fields be compressed"""
  fields_be_compressed: [FieldCompressionInfo!]!

  """space name"""
  space_name: String!
}

"""Failover state provider status"""
type StateProviderStatus {
  """State provider uri"""
  uri: String!

  """State provider status"""
  status: Boolean!
}

type Suggestions {
  force_apply: [ForceApplySuggestion!]
  restart_replication: [RestartReplicationSuggestion!]
  refine_uri: [RefineUriSuggestion!]
  disable_servers: [DisableServerSuggestion!]
}

"""A single user account information"""
type User {
  username: String!
  fullname: String
  email: String
}

"""User managent parameters and available operations"""
type UserManagementAPI {
  implements_remove_user: Boolean!
  implements_add_user: Boolean!
  implements_edit_user: Boolean!

  """Number of seconds until the authentication cookie expires."""
  cookie_max_age: Long!

  """Update provided cookie if it's older then this age."""
  cookie_renew_age: Long!
  implements_list_users: Boolean!

  """Whether authentication is enabled."""
  enabled: Boolean!

  """Active session username."""
  username: String
  implements_get_user: Boolean!
  implements_check_password: Boolean!
}

"""Result of config validation"""
type ValidateConfigResult {
  """Error details if validation fails, null otherwise"""
  error: String
}

"""Group of replicasets sharding the same dataset"""
type VshardGroup {
  """
  The maximum number of buckets that can be received in parallel by a single replica set in the storage group
  """
  rebalancer_max_receiving: Int!

  """Virtual buckets count in the group"""
  bucket_count: Int!

  """The interval between garbage collector actions, in seconds"""
  collect_bucket_garbage_interval: Float @deprecated(reason: "Has no effect anymore")

  """
  If set to true, the Lua collectgarbage() function is called periodically
  """
  collect_lua_garbage: Boolean @deprecated(reason: "Has no effect anymore")

  """Scheduler storage ref quota"""
  sched_ref_quota: Long!

  """Rebalancer mode"""
  rebalancer_mode: String!

  """
  Timeout to wait for synchronization of the old master with replicas before demotion
  """
  sync_timeout: Float!

  """
  The maximum number of buckets that can be sent in parallel by a single replica set in the storage group
  """
  rebalancer_max_sending: Int!

  """Whether the group is ready to operate"""
  bootstrapped: Boolean!

  """A maximum bucket disbalance threshold, in percent"""
  rebalancer_disbalance_threshold: Float!

  """Group name"""
  name: String!

  """Scheduler bucket move quota"""
  sched_move_quota: Long!
}

type VshardRouter {
  """The number of buckets whose replica sets are not known to the router"""
  buckets_unknown: Int

  """
  The number of buckets known to the router and available for read and write requests
  """
  buckets_available_rw: Int

  """Vshard group"""
  vshard_group: String

  """
  The number of buckets known to the router but unavailable for any requests
  """
  buckets_unreachable: Int

  """
  The number of buckets known to the router and available for read requests
  """
  buckets_available_ro: Int
}