{
  "components": {
    "responses": {
      "Conflict": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Conflict"
      },
      "Forbidden": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Forbidden"
      },
      "NotAcceptable": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Not Acceptable"
      },
      "NotFound": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Not Found"
      },
      "ServiceUnavailable": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Service Unavailable"
      },
      "cluster_BadRequest": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Bad Request"
      },
      "cluster_InternalServerError": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/cluster_Error"
            }
          }
        },
        "description": "Internal Server Error"
      }
    },
    "schemas": {
      "ActiveActive": {
        "properties": {
          "available": {
            "description": "Whether every replication link is up",
            "type": "boolean"
          },
          "participating_clusters": {
            "items": {
              "$ref": "#/components/schemas/Source"
            },
            "type": "array"
          }
        },
        "required": [
          "available",
          "participating_clusters"
        ],
        "type": "object"
      },
      "Alert": {
        "description": "Alert information",
        "properties": {
          "active_since": {
            "description": "Since what time the alert is active",
            "format": "date-time",
            "type": "string"
          },
          "name": {
            "description": "Alert name",
            "type": "string"
          },
          "severity": {
            "description": "Severity level of the alert",
            "type": "string"
          },
          "threshold": {
            "description": "Threshold for the alert",
            "type": "string"
          }
        },
        "required": [
          "name",
          "active_since"
        ],
        "type": "object"
      },
      "BdbPasswordRequest": {
        "description": "Request body for database password operations",
        "example": {
          "password": "my-secure-password"
        },
        "properties": {
          "password": {
            "description": "The password to add, delete, or set",
            "type": "string"
          }
        },
        "required": [
          "password"
        ],
        "type": "object"
      },
      "BdbProxyCertificate": {
        "description": "Bdb proxy certificate",
        "properties": {
          "bdb_uid": {
            "description": "BDB UID that this certificate belongs to",
            "readOnly": true,
            "type": "string"
          },
          "cert": {
            "description": "PEM-encoded certificate",
            "type": "string"
          },
          "not_after": {
            "description": "Date the certificate is valid until. Parsed from the certificate.",
            "format": "date-time",
            "readOnly": true,
            "type": "string"
          },
          "not_before": {
            "description": "Date the certificate is valid from. Parsed from the certificate.",
            "format": "date-time",
            "readOnly": true,
            "type": "string"
          },
          "private_key": {
            "description": "PEM-encoded private key",
            "type": "string",
            "writeOnly": true
          }
        },
        "type": "object"
      },
      "BdbProxyCertificateSetRequest": {
        "description": "Request body for setting a bdb proxy certificate",
        "properties": {
          "cert": {
            "description": "PEM-encoded certificate",
            "type": "string"
          },
          "private_key": {
            "description": "PEM-encoded private key",
            "type": "string"
          }
        },
        "required": [
          "cert",
          "private_key"
        ],
        "type": "object"
      },
      "Certificate": {
        "description": "Certificate information.",
        "properties": {
          "expired": {
            "description": "Whether the certificate has expired",
            "type": "boolean"
          },
          "type": {
            "description": "Certificate type",
            "type": "string"
          },
          "valid_until": {
            "description": "Certificate expiration time",
            "format": "date-time",
            "type": "string"
          }
        },
        "required": [
          "type",
          "expired",
          "valid_until"
        ],
        "type": "object"
      },
      "CertificateRotateRequest": {
        "description": "Request body for rotating internal certificates.",
        "properties": {
          "name": {
            "description": "Optional internal certificate name to rotate. When omitted, all supported internal certificates are rotated.",
            "type": "string",
            "x-omitempty": true
          }
        },
        "type": "object"
      },
      "ChangePasswordHashingAlgorithmRequest": {
        "description": "Request to change the cluster password hashing algorithm",
        "properties": {
          "algorithm": {
            "description": "The password hashing algorithm to use for all users",
            "enum": [
              "SHA-256",
              "PBKDF2"
            ],
            "type": "string"
          }
        },
        "required": [
          "algorithm"
        ],
        "type": "object"
      },
      "ClusterCertificateUpdate": {
        "additionalProperties": false,
        "description": "Cluster certificate payload used for updates.",
        "properties": {
          "certificate": {
            "description": "PEM-encoded certificate chain.",
            "type": "string"
          },
          "key": {
            "description": "PEM-encoded private key.",
            "type": "string"
          },
          "name": {
            "description": "Certificate type name.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "ClusterCertificatesResponse": {
        "description": "Cluster certificates response",
        "properties": {
          "api_cert": {
            "description": "PEM-encoded API certificate",
            "type": "string",
            "x-omitempty": true
          },
          "api_key": {
            "description": "PEM-encoded private key for the API certificate",
            "type": "string",
            "x-omitempty": true
          },
          "ccs_internode_encryption_cert": {
            "description": "PEM-encoded CCS internode encryption certificate",
            "type": "string",
            "x-omitempty": true
          },
          "ccs_internode_encryption_key": {
            "description": "PEM-encoded private key for the CCS internode encryption certificate",
            "type": "string",
            "x-omitempty": true
          },
          "cm_cert": {
            "description": "PEM-encoded cluster manager certificate",
            "type": "string",
            "x-omitempty": true
          },
          "cm_key": {
            "description": "PEM-encoded private key for the cluster manager certificate",
            "type": "string",
            "x-omitempty": true
          },
          "data_internode_encryption_cert": {
            "description": "PEM-encoded data internode encryption certificate",
            "type": "string",
            "x-omitempty": true
          },
          "data_internode_encryption_key": {
            "description": "PEM-encoded private key for the data internode encryption certificate",
            "type": "string",
            "x-omitempty": true
          },
          "ldap_client_cert": {
            "description": "PEM-encoded LDAP client certificate",
            "type": "string",
            "x-omitempty": true
          },
          "ldap_client_key": {
            "description": "PEM-encoded private key for the LDAP client certificate",
            "type": "string",
            "x-omitempty": true
          },
          "metrics_exporter_cert": {
            "description": "PEM-encoded metrics exporter certificate",
            "type": "string",
            "x-omitempty": true
          },
          "metrics_exporter_key": {
            "description": "PEM-encoded private key for the metrics exporter certificate",
            "type": "string",
            "x-omitempty": true
          },
          "mtls_trusted_ca_cert": {
            "description": "PEM-encoded trusted CA certificate for mTLS client authentication",
            "type": "string",
            "x-omitempty": true
          },
          "proxy_cert": {
            "description": "PEM-encoded proxy certificate",
            "type": "string",
            "x-omitempty": true
          },
          "proxy_key": {
            "description": "PEM-encoded private key for the proxy certificate",
            "type": "string",
            "x-omitempty": true
          },
          "sso_issuer_cert": {
            "description": "PEM-encoded SSO issuer certificate",
            "type": "string",
            "x-omitempty": true
          },
          "sso_service_cert": {
            "description": "PEM-encoded SSO service certificate",
            "type": "string",
            "x-omitempty": true
          },
          "sso_service_key": {
            "description": "PEM-encoded private key for the SSO service certificate",
            "type": "string",
            "x-omitempty": true
          },
          "syncer_cert": {
            "description": "PEM-encoded syncer certificate",
            "type": "string",
            "x-omitempty": true
          },
          "syncer_key": {
            "description": "PEM-encoded private key for the syncer certificate",
            "type": "string",
            "x-omitempty": true
          }
        },
        "type": "object"
      },
      "ClusterCertificatesUpdateRequest": {
        "additionalProperties": false,
        "description": "Request body for updating one or more cluster certificates.",
        "properties": {
          "certificates": {
            "description": "Certificates to update.",
            "items": {
              "$ref": "#/components/schemas/ClusterCertificateUpdate"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "ClusterHealthReport": {
        "description": "Cluster health report.",
        "properties": {
          "active_alerts": {
            "items": {
              "$ref": "#/components/schemas/Alert"
            },
            "type": "array"
          },
          "certificates": {
            "description": "List of certificates in the cluster",
            "items": {
              "$ref": "#/components/schemas/Certificate"
            },
            "type": "array"
          },
          "database_infos": {
            "items": {
              "$ref": "#/components/schemas/DatabaseInfo"
            },
            "type": "array"
          },
          "fqdn": {
            "description": "Cluster FQDN",
            "type": "string"
          },
          "license": {
            "$ref": "#/components/schemas/LicenseHealthReport"
          },
          "nodes": {
            "description": "List of nodes in the cluster",
            "items": {
              "$ref": "#/components/schemas/NodeHealthReport"
            },
            "type": "array"
          },
          "status": {
            "description": "Cluster status",
            "enum": [
              "error",
              "warning",
              "ok"
            ],
            "type": "string"
          }
        },
        "required": [
          "fqdn",
          "status",
          "license",
          "certificates",
          "nodes",
          "active_alerts",
          "database_infos"
        ],
        "type": "object"
      },
      "DatabaseHealthReport": {
        "properties": {
          "active_active": {
            "$ref": "#/components/schemas/ActiveActive"
          },
          "active_alerts": {
            "description": "List of active alerts for the database",
            "items": {
              "$ref": "#/components/schemas/Alert"
            },
            "type": "array"
          },
          "availability": {
            "$ref": "#/components/schemas/replication_status"
          },
          "availability_errors": {
            "description": "List of errors that caused the BDB to be unavailable",
            "items": {
              "enum": [
                "general_error",
                "port_unbound",
                "shard_unreachable"
              ],
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "creation_time": {
            "description": "Database creation time.",
            "format": "date-time",
            "type": "string"
          },
          "detailed_status": {
            "$ref": "#/components/schemas/database_detailed_status"
          },
          "endpoints": {
            "description": "Database endpoints.",
            "items": {
              "$ref": "#/components/schemas/Endpoint"
            },
            "type": "array"
          },
          "high_availability": {
            "$ref": "#/components/schemas/HighAvailability"
          },
          "id": {
            "description": "Database id",
            "type": "string"
          },
          "last_backup_time": {
            "description": "Database last backup time.",
            "format": "date-time",
            "nullable": true,
            "type": "string"
          },
          "last_configured_time": {
            "description": "Database last configuration time.",
            "format": "date-time",
            "type": "string"
          },
          "name": {
            "description": "Database name",
            "type": "string"
          },
          "persistence": {
            "default": "disabled",
            "description": "Database persistence type.",
            "enum": [
              "disabled",
              "aof",
              "rdb"
            ],
            "type": "string"
          },
          "shards": {
            "description": "Database shards.",
            "items": {
              "$ref": "#/components/schemas/ShardHealthReport"
            },
            "type": "array"
          },
          "shards_placement": {
            "description": "Database shards placement.",
            "enum": [
              "dense",
              "sparse"
            ],
            "type": "string"
          },
          "state_machine": {
            "$ref": "#/components/schemas/StateMachine"
          },
          "status": {
            "$ref": "#/components/schemas/database_status"
          },
          "version": {
            "description": "Database version.",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "availability",
          "high_availability",
          "status",
          "detailed_status",
          "version",
          "creation_time",
          "last_configured_time",
          "persistence",
          "shards_placement",
          "endpoints",
          "shards",
          "active_alerts"
        ],
        "type": "object"
      },
      "DatabaseInfo": {
        "description": "Database info",
        "properties": {
          "detailed_status": {
            "$ref": "#/components/schemas/database_detailed_status"
          },
          "high_availability": {
            "$ref": "#/components/schemas/HighAvailability"
          },
          "id": {
            "description": "DB id",
            "type": "string"
          },
          "name": {
            "description": "DB name",
            "type": "string"
          },
          "status": {
            "$ref": "#/components/schemas/database_status"
          },
          "version": {
            "description": "DB version",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "status",
          "detailed_status",
          "version",
          "high_availability"
        ],
        "type": "object"
      },
      "Endpoint": {
        "description": "Endpoint information",
        "properties": {
          "availability": {
            "$ref": "#/components/schemas/replication_status"
          },
          "name": {
            "description": "Endpoint name",
            "type": "string"
          }
        },
        "required": [
          "name",
          "availability"
        ],
        "type": "object"
      },
      "HighAvailability": {
        "properties": {
          "status": {
            "$ref": "#/components/schemas/high_availability_status"
          }
        },
        "required": [
          "status"
        ],
        "type": "object"
      },
      "Ldap": {
        "additionalProperties": false,
        "description": "An API object that represents the cluster's LDAP configuration.",
        "properties": {
          "bind_dn": {
            "description": "A DN to use when binding with the LDAP server to run queries",
            "type": "string"
          },
          "bind_pass": {
            "description": "A password to use when binding with the LDAP server to run queries. Returned as a masked value on GET.",
            "type": "string"
          },
          "ca_cert": {
            "description": "A PEM-encoded CA certificate(s) to use for validating TLS connections to the LDAP server",
            "type": "string"
          },
          "cache_ttl": {
            "default": 300,
            "description": "Maximum TTL of cached entries, in seconds",
            "minimum": 0,
            "type": "integer"
          },
          "cba": {
            "default": false,
            "description": "Whether to allow LDAP as an identity source for certificate-based authentication",
            "type": "boolean"
          },
          "cba_identity_oid": {
            "description": "The certificate subject OID to use when cba_identity_source is set to subject_oid",
            "type": "string"
          },
          "cba_identity_source": {
            "description": "The certificate subject identity source to use for LDAP lookup",
            "enum": [
              "subject_cn",
              "subject_oid"
            ],
            "type": "string"
          },
          "control_plane": {
            "default": false,
            "description": "Whether to use LDAP for user authentication/authorization in the control-plane",
            "type": "boolean"
          },
          "data_plane": {
            "default": false,
            "description": "Whether to use LDAP for user authentication/authorization in the data-plane",
            "type": "boolean"
          },
          "directory_timeout_s": {
            "default": 5,
            "description": "The connection timeout to the LDAP server when authenticating a user, in seconds",
            "maximum": 60,
            "minimum": 5,
            "type": "integer"
          },
          "dn_group_attr": {
            "description": "The name of an attribute of the LDAP user entity that contains a list of the groups that user belongs to. (Mutually exclusive with \"dn_group_query\")",
            "type": "string"
          },
          "dn_group_query": {
            "$ref": "#/components/schemas/LdapQuery"
          },
          "starttls": {
            "default": false,
            "description": "Whether to use StartTLS negotiation for the LDAP connection",
            "type": "boolean"
          },
          "uris": {
            "description": "URIs of LDAP servers containing only the schema, the host, and the port",
            "items": {
              "pattern": "^(ldap|ldaps)://([a-zA-Z0-9.\\-%]+|\\[[a-fA-F0-9:%]+\\]):[0-9]{1,5}$",
              "type": "string"
            },
            "type": "array"
          },
          "user_dn_query": {
            "$ref": "#/components/schemas/LdapQuery"
          },
          "user_dn_template": {
            "description": "A string template that maps between the username provided to the cluster for authentication, and the LDAP DN. The special substring \"%u\" shall be replaced with the username. (Mutually exclusive with \"user_dn_query\")",
            "type": "string"
          }
        },
        "type": "object"
      },
      "LdapMapping": {
        "allOf": [
          {
            "$ref": "#/components/schemas/LdapMappingBody"
          },
          {
            "properties": {
              "action_uid": {
                "description": "Action uid. If exists - progress can be tracked by the GET /actions/\u003cuid\u003e API.",
                "type": "string"
              },
              "uid": {
                "description": "LDAP mapping's unique uid.",
                "type": "integer",
                "x-go-type": "json.Number"
              }
            },
            "required": [
              "uid",
              "name",
              "dn",
              "email",
              "email_alerts",
              "role_uids"
            ],
            "type": "object"
          }
        ],
        "description": "An API object that represents a Redis Software LDAP mapping.",
        "example": {
          "dn": "OU=ops.group,DC=redislabs,DC=com",
          "email": "ops.group@redislabs.com",
          "email_alerts": true,
          "name": "Admins",
          "role_uids": [
            1
          ],
          "uid": 17
        }
      },
      "LdapMappingBody": {
        "description": "Common LDAP mapping properties shared across LDAP mapping payloads.",
        "properties": {
          "account_id": {
            "description": "SM account ID.",
            "type": "integer"
          },
          "bdbs_email_alerts": {
            "description": "UIDs of databases that LDAP mapping users will receive alerts for.",
            "items": {
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "cluster_email_alerts": {
            "description": "Activate cluster email alerts for an LDAP mapping.",
            "type": "boolean"
          },
          "dn": {
            "description": "LDAP group's distinguished name.",
            "minLength": 1,
            "pattern": "\\S",
            "type": "string",
            "x-pattern-error-message": "must contain at least one non-whitespace character"
          },
          "email": {
            "description": "LDAP mapping's email.",
            "pattern": "(^$|^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)",
            "type": "string",
            "x-pattern-error-message": "must be empty or a valid email address"
          },
          "email_alerts": {
            "default": true,
            "description": "Activate email alerts for an LDAP mapping.",
            "type": "boolean"
          },
          "name": {
            "description": "LDAP mapping's name.",
            "maxLength": 255,
            "pattern": "^[a-zA-Z0-9_ \\[\\]()@,.;#-]+$",
            "type": "string",
            "x-pattern-error-message": "may contain only letters, numbers, spaces, and the characters _ [] () @ , . ; # -"
          },
          "role_uids": {
            "description": "List of role uids associated with the LDAP mapping.",
            "items": {
              "type": "integer",
              "x-go-type": "json.Number"
            },
            "minItems": 1,
            "type": "array"
          }
        },
        "type": "object"
      },
      "LdapMappingCreateRequest": {
        "allOf": [
          {
            "$ref": "#/components/schemas/LdapMappingBody"
          },
          {
            "required": [
              "name",
              "dn",
              "role_uids"
            ],
            "type": "object"
          }
        ],
        "description": "Request body for creating a Redis Software LDAP mapping.",
        "example": {
          "dn": "OU=ops.group,DC=redislabs,DC=com",
          "email": "ops.group@redislabs.com",
          "email_alerts": true,
          "name": "Admins",
          "role_uids": [
            1
          ]
        }
      },
      "LdapMappingUpdateRequest": {
        "allOf": [
          {
            "$ref": "#/components/schemas/LdapMappingBody"
          }
        ],
        "description": "Request body for updating a Redis Software LDAP mapping.",
        "example": {
          "dn": "OU=ops.group,DC=redislabs,DC=com",
          "email": "ops.group@redislabs.com",
          "email_alerts": true,
          "name": "Admins",
          "role_uids": [
            1
          ]
        }
      },
      "LdapQuery": {
        "additionalProperties": false,
        "oneOf": [
          {
            "maxProperties": 0
          },
          {
            "required": [
              "base",
              "scope",
              "filter"
            ]
          }
        ],
        "properties": {
          "base": {
            "description": "The DN of the entry at which to start the search",
            "type": "string"
          },
          "filter": {
            "description": "An RFC-4515 string representation of the filter to apply in the search",
            "type": "string"
          },
          "scope": {
            "description": "One of \"base\" (to search the base object itself), \"one\" (to search the base object's immediate children), or \"subtree\" (to search the base object and all its descendants)",
            "enum": [
              "base",
              "one",
              "subtree"
            ],
            "type": "string"
          }
        },
        "type": "object"
      },
      "LicenseHealthReport": {
        "description": "License health report.",
        "properties": {
          "expired": {
            "description": "Whether the license has expired",
            "type": "boolean"
          },
          "flex_shards_in_use": {
            "description": "Number of Flex shards in use by databases in the cluster",
            "type": "integer"
          },
          "flex_shards_limit": {
            "description": "Flex shards limit specified in cluster license",
            "type": "integer"
          },
          "ram_shards_in_use": {
            "description": "Number of RAM shards in use by databases in the cluster",
            "type": "integer"
          },
          "ram_shards_limit": {
            "description": "RAM shards limit specified in cluster license",
            "type": "integer"
          },
          "shards_in_use": {
            "description": "Accumulated number of shards in use by databases in the cluster",
            "type": "integer"
          },
          "shards_limit": {
            "description": "Shards limit specified in cluster license",
            "type": "integer"
          },
          "valid_until": {
            "description": "License expiration time",
            "format": "date-time",
            "type": "string"
          }
        },
        "required": [
          "expired",
          "shards_in_use",
          "ram_shards_in_use",
          "flex_shards_in_use",
          "shards_limit",
          "ram_shards_limit",
          "flex_shards_limit",
          "valid_until"
        ],
        "type": "object"
      },
      "Memory": {
        "description": "Memory information",
        "properties": {
          "free_provisional_ram": {
            "description": "Remaining ram for provisioning new shards on the node",
            "format": "int64",
            "type": "integer"
          },
          "free_ram": {
            "description": "Free ram the node has in bytes",
            "format": "int64",
            "type": "integer"
          },
          "overbooking_depth": {
            "description": "How much the node is overbooked or has capacity remaining, like free provisional ram but takes into account shards_overbooking (can be negative if it is overbooked)",
            "format": "int64",
            "type": "integer"
          },
          "total_provisional_ram": {
            "description": "Total ram for provisioning shards on the node",
            "format": "int64",
            "type": "integer"
          },
          "total_ram": {
            "description": "Total ram the node has in bytes",
            "format": "int64",
            "type": "integer"
          }
        },
        "required": [
          "total_ram",
          "free_ram",
          "free_provisional_ram",
          "total_provisional_ram",
          "overbooking_depth"
        ],
        "type": "object"
      },
      "Migration": {
        "description": "Object structure for migration status.",
        "properties": {
          "error": {
            "$ref": "#/components/schemas/MigrationError"
          },
          "flush_counter": {
            "description": "How many times syncer had to restart.",
            "nullable": true,
            "readOnly": true,
            "type": "integer",
            "x-omitempty": true
          },
          "lag": {
            "description": "Lag in milliseconds between source and destination (while synced).",
            "nullable": true,
            "readOnly": true,
            "type": "integer",
            "x-omitempty": true
          },
          "rdb_size": {
            "description": "Number of source bytes.",
            "nullable": true,
            "readOnly": true,
            "type": "integer",
            "x-omitempty": true
          },
          "rdb_transferred": {
            "description": "Number of source bytes transferred.",
            "nullable": true,
            "readOnly": true,
            "type": "integer",
            "x-omitempty": true
          },
          "run_id": {
            "description": "Syncer run id.",
            "nullable": true,
            "readOnly": true,
            "type": "string",
            "x-omitempty": true
          },
          "source_shards": {
            "items": {
              "$ref": "#/components/schemas/SourceShard"
            },
            "readOnly": true,
            "type": "array"
          },
          "status": {
            "description": "Sync status of this source.",
            "nullable": true,
            "readOnly": true,
            "type": "string",
            "x-omitempty": true
          }
        },
        "type": "object"
      },
      "MigrationError": {
        "description": "Error information for migration operations",
        "properties": {
          "error_code": {
            "description": "Error code identifying the specific error",
            "nullable": true,
            "readOnly": true,
            "type": "string",
            "x-omitempty": true
          },
          "message": {
            "description": "Human-readable error message",
            "nullable": true,
            "readOnly": true,
            "type": "string",
            "x-omitempty": true
          },
          "timestamp": {
            "description": "Timestamp when the error occurred",
            "format": "date-time",
            "nullable": true,
            "readOnly": true,
            "type": "string",
            "x-omitempty": true
          }
        },
        "type": "object"
      },
      "MigrationResponse": {
        "description": "Response wrapper for migration endpoint",
        "properties": {
          "migration": {
            "$ref": "#/components/schemas/Migration"
          }
        },
        "type": "object"
      },
      "NodeHealthReport": {
        "description": "Node information.",
        "properties": {
          "active_alerts": {
            "items": {
              "$ref": "#/components/schemas/Alert"
            },
            "type": "array"
          },
          "detailed_status": {
            "description": "Node detailed status",
            "enum": [
              "down",
              "provisioning",
              "decommissioning",
              "active"
            ],
            "type": "string"
          },
          "ephemeral_memory_path": {
            "description": "Path to ephemeral storage on the node",
            "type": "string"
          },
          "ephemeral_memory_size": {
            "description": "Size of ephemeral storage on the node in bytes",
            "format": "double",
            "type": "number"
          },
          "id": {
            "description": "Node id",
            "type": "string"
          },
          "in_maintenance": {
            "description": "Whether the node is in maintenance mode",
            "type": "boolean"
          },
          "memory": {
            "$ref": "#/components/schemas/Memory"
          },
          "observed_at": {
            "description": "Unix time in seconds when the value was last written in the CCS",
            "format": "int64",
            "type": "integer"
          },
          "persistent_memory_path": {
            "description": "Path to persistent storage on the node",
            "type": "string"
          },
          "persistent_memory_size": {
            "description": "Size of persistent storage on the node in bytes",
            "format": "double",
            "type": "number"
          },
          "quorum_only": {
            "description": "Whether the node is quorum-only (does not accept servers)",
            "type": "boolean"
          },
          "role": {
            "description": "Node role can be leader or follower",
            "enum": [
              "leader",
              "follower"
            ],
            "type": "string"
          },
          "services": {
            "items": {
              "$ref": "#/components/schemas/Service"
            },
            "type": "array"
          },
          "shards": {
            "description": "Shards on the node.",
            "items": {
              "$ref": "#/components/schemas/ShardHealthReport"
            },
            "type": "array"
          },
          "status": {
            "description": "Node status",
            "enum": [
              "down",
              "warning",
              "active"
            ],
            "type": "string"
          },
          "version": {
            "description": "RS version installed on the node",
            "type": "string"
          }
        },
        "required": [
          "id",
          "status",
          "detailed_status",
          "role",
          "version",
          "shards",
          "memory",
          "observed_at",
          "services",
          "ephemeral_memory_path",
          "ephemeral_memory_size",
          "persistent_memory_path",
          "persistent_memory_size",
          "quorum_only",
          "in_maintenance"
        ],
        "type": "object"
      },
      "OcspConfig": {
        "additionalProperties": false,
        "description": "OCSP configuration",
        "properties": {
          "ocsp_functionality": {
            "description": "Whether to enable/disable OCSP for the cluster.",
            "type": "boolean"
          },
          "query_frequency": {
            "description": "Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate.",
            "maximum": 86400,
            "minimum": 60,
            "type": "integer"
          },
          "recovery_frequency": {
            "description": "Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate when the current staple is invalid.",
            "maximum": 86400,
            "minimum": 60,
            "type": "integer"
          },
          "recovery_max_tries": {
            "description": "Determines the maximum number for the OCSP recovery attempts. After max number of tries passed, the control plane will revert back to the regular frequency.",
            "maximum": 100,
            "minimum": 1,
            "type": "integer"
          },
          "responder_url": {
            "description": "The OCSP server url embedded in the proxy certificate (if available)",
            "readOnly": true,
            "type": "string"
          },
          "response_timeout": {
            "description": "Determines the time interval (in seconds) for which the request waits for a response from the OCSP responder.",
            "maximum": 60,
            "minimum": 1,
            "type": "integer"
          }
        },
        "type": "object"
      },
      "OcspStatus": {
        "description": "OCSP status",
        "properties": {
          "cert_status": {
            "description": "Indicates the proxy certificate status: GOOD/REVOKED/UNKNOWN.",
            "type": "string"
          },
          "next_update": {
            "description": "The time at or before which newer information will be available about the status of the certificate (if available)",
            "type": "string"
          },
          "produced_at": {
            "description": "The time at which the OCSP responder signed this response.",
            "type": "string"
          },
          "responder_url": {
            "description": "The OCSP responder url from which this status came from.",
            "type": "string"
          },
          "revocation_time": {
            "description": "The time at which the certificate was revoked or placed on hold.",
            "type": "string"
          },
          "this_update": {
            "description": "The most recent time at which the status being indicated is known by the responder to have been correct.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "PasswordHashMethod": {
        "description": "Used when password is passed pre-hashed",
        "enum": [
          1
        ],
        "type": "integer",
        "x-enum-varnames": [
          "PreHashed"
        ]
      },
      "Permissions": {
        "description": "API and UI permissions for a role",
        "example": {
          "api_permissions": [
            "create_node",
            "update_node",
            "delete_node"
          ],
          "ui_permissions": [
            "view_cluster_page",
            "view_database_page"
          ]
        },
        "properties": {
          "api_permissions": {
            "description": "List of permission strings",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "ui_permissions": {
            "description": "List of permission strings",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "RedisAcl": {
        "description": "An API object that represents a Redis ACL definition.",
        "example": {
          "acl": "on \u003eallcommands allkeys",
          "max_version": "9999",
          "min_version": "6.2",
          "name": "default",
          "uid": 1
        },
        "properties": {
          "account_id": {
            "description": "SM account ID associated with this ACL.",
            "type": "integer",
            "x-go-type": "int64"
          },
          "acl": {
            "description": "Redis ACL string definition.",
            "type": "string"
          },
          "action_uid": {
            "description": "Action uid. If exists - progress can be tracked by the GET /actions/\u003cuid\u003e API",
            "readOnly": true,
            "type": "string"
          },
          "max_version": {
            "description": "Maximum Redis version for which this ACL is valid.",
            "readOnly": true,
            "type": "string"
          },
          "min_version": {
            "description": "Minimum Redis version for which this ACL is valid.",
            "readOnly": true,
            "type": "string"
          },
          "name": {
            "description": "ACL name.",
            "pattern": "^[a-zA-Z0-9_ \\[\\]()@,.;#-]+$",
            "type": "string"
          },
          "uid": {
            "description": "Redis ACL unique uid.",
            "type": "integer",
            "x-go-type": "json.Number"
          }
        },
        "type": "object"
      },
      "Resource": {
        "description": "Defines a resource for a role, restricting access to specific resources.",
        "properties": {
          "type": {
            "$ref": "#/components/schemas/ResourceType"
          },
          "uids": {
            "description": "List of resource UIDs this role has access to.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "ResourceType": {
        "description": "Type of resource for scoping role access.",
        "enum": [
          "db"
        ],
        "type": "string"
      },
      "Role": {
        "allOf": [
          {
            "$ref": "#/components/schemas/RoleBody"
          },
          {
            "properties": {
              "uid": {
                "description": "Role's unique uid.",
                "type": "integer",
                "x-go-type": "json.Number"
              }
            },
            "required": [
              "uid",
              "name",
              "management"
            ],
            "type": "object"
          }
        ],
        "description": "An API object that represents a Redis Software role.",
        "example": {
          "management": "cluster_member",
          "name": "DBA",
          "uid": 1
        }
      },
      "RoleBody": {
        "description": "Common role properties shared across role payloads.",
        "properties": {
          "account_id": {
            "description": "Account ID. Only applicable to account-scoped roles.",
            "type": "integer"
          },
          "management": {
            "$ref": "#/components/schemas/RoleName"
          },
          "name": {
            "description": "Role's name.",
            "pattern": "^[a-zA-Z0-9_ \\[\\]()@,.;#-]+$",
            "type": "string"
          },
          "resources": {
            "description": "Resources that restrict this role's access to specific resources.",
            "items": {
              "$ref": "#/components/schemas/Resource"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "RoleCreateRequest": {
        "allOf": [
          {
            "$ref": "#/components/schemas/RoleBody"
          },
          {
            "properties": {
              "uid": {
                "description": "Optional uid to assign to the role.",
                "type": "integer",
                "x-go-type": "json.Number"
              }
            },
            "type": "object"
          }
        ],
        "description": "Role creation request payload.",
        "example": {
          "management": "cluster_viewer",
          "name": "Support Engineer"
        }
      },
      "RoleName": {
        "description": "Name of the management role.",
        "enum": [
          "none",
          "db_viewer",
          "cluster_viewer",
          "db_member",
          "cluster_member",
          "user_manager",
          "admin"
        ],
        "type": "string"
      },
      "RoleUpdateRequest": {
        "allOf": [
          {
            "$ref": "#/components/schemas/RoleBody"
          },
          {
            "type": "object"
          }
        ],
        "description": "Role update request payload.",
        "example": {
          "management": "cluster_member"
        }
      },
      "RolesWithPermissions": {
        "additionalProperties": {
          "$ref": "#/components/schemas/Permissions"
        },
        "description": "A map of role names to their permissions",
        "type": "object"
      },
      "Service": {
        "description": "Services running on the node managed by supervisor",
        "properties": {
          "name": {
            "description": "Name of the service",
            "type": "string"
          },
          "status": {
            "description": "Status of the service corresponding to the statename returned by supervisor",
            "type": "string"
          }
        },
        "required": [
          "name",
          "status"
        ],
        "type": "object"
      },
      "ShardHealthReport": {
        "properties": {
          "detailed_status": {
            "description": "shard detailed status",
            "enum": [
              "ok",
              "importing",
              "timeout",
              "loading",
              "busy",
              "down",
              "trimming",
              "unknown",
              "role_mismatch"
            ],
            "type": "string"
          },
          "id": {
            "type": "string"
          },
          "role": {
            "description": "shard role can be leader or follower",
            "enum": [
              "leader",
              "follower"
            ],
            "type": "string"
          },
          "status": {
            "description": "shard status can be up or trimming",
            "enum": [
              "active",
              "inactive",
              "trimming"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "role",
          "status",
          "detailed_status"
        ],
        "type": "object"
      },
      "Source": {
        "properties": {
          "fqdn": {
            "description": "fqdn of the cluster",
            "type": "string"
          },
          "replica_id": {
            "type": "string"
          },
          "replication": {
            "description": "replication status of replica",
            "enum": [
              "down",
              "warning",
              "up"
            ],
            "type": "string"
          }
        },
        "required": [
          "fqdn",
          "replication",
          "replica_id"
        ],
        "type": "object"
      },
      "SourceShard": {
        "description": "Replication shard with its metadata",
        "properties": {
          "replication_id": {
            "description": "Replication id",
            "readOnly": true,
            "type": "string"
          },
          "replication_offset": {
            "description": "Replication offset",
            "format": "uint64",
            "readOnly": true,
            "type": "integer"
          }
        },
        "type": "object"
      },
      "StateMachine": {
        "description": "State machine information",
        "properties": {
          "name": {
            "description": "State machine name",
            "type": "string"
          },
          "state": {
            "description": "State machine state",
            "type": "string"
          }
        },
        "required": [
          "name",
          "state"
        ],
        "type": "object"
      },
      "User": {
        "description": "An API object that represents an Redis Software Cluster user.",
        "example": {
          "auth_method": "regular",
          "email": "user@redis.com",
          "email_alerts": true,
          "last_login": 1760618047,
          "name": "John Doe",
          "password_issue_date": "2025-03-02T09:43:34Z",
          "role_uids": [
            1
          ],
          "status": "active"
        },
        "properties": {
          "account_id": {
            "description": "SM account ID",
            "type": "integer"
          },
          "action_uid": {
            "description": "Action uid. If exists - progress can be tracked by the GET /actions/\u003cuid\u003e API",
            "type": "string"
          },
          "auth_method": {
            "enum": [
              "regular",
              "certificate",
              "entraid",
              "sso"
            ],
            "type": "string"
          },
          "bdbs_email_alerts": {
            "description": "UIDs of databases that user will receive alerts for.",
            "items": {
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "certificate_subject_line": {
            "description": "The certificate's subject line as defined by RFC2253 (for certificate based authentication users only)",
            "type": "string"
          },
          "cluster_email_alerts": {
            "description": "Activate cluster email alerts for a user.",
            "type": "boolean"
          },
          "email": {
            "description": "User's email. (pattern matching only ascii characters)",
            "type": "string"
          },
          "email_alerts": {
            "default": true,
            "description": "Activate email alerts for a user.",
            "type": "boolean"
          },
          "last_login": {
            "description": "Timestamp of the user's last login time. This denotes the last time an authentication with the user's credentials was successful.",
            "format": "int64",
            "type": "integer"
          },
          "name": {
            "description": "User's name. (pattern does not allow non ascii and special characters \u0026,\u003c,\u003e,\")",
            "type": "string"
          },
          "password": {
            "description": "User's password. Note that it could also be an already-hashed value, in which case 'password_hash_method' parameter is also provided.",
            "type": "string"
          },
          "password_issue_date": {
            "description": "The date in which the password was set.",
            "format": "date-time",
            "type": "string"
          },
          "role": {
            "allOf": [
              {
                "$ref": "#/components/schemas/RoleName"
              }
            ],
            "deprecated": true,
            "description": "(deprecated) User's role.",
            "x-deprecated-reason": "Use role_uids instead"
          },
          "role_uids": {
            "description": "List of role uids associated with the user",
            "items": {
              "type": "integer",
              "x-go-type": "json.Number"
            },
            "type": "array"
          },
          "status": {
            "description": "Status of the user.",
            "enum": [
              "active",
              "locked",
              "password_expired"
            ],
            "type": "string"
          },
          "uid": {
            "description": "User's unique uid.",
            "type": "integer",
            "x-go-type": "json.Number"
          }
        },
        "required": [
          "uid",
          "name",
          "role",
          "role_uids",
          "auth_method"
        ],
        "type": "object"
      },
      "UserRequest": {
        "description": "User modification request.",
        "properties": {
          "account_id": {
            "description": "SM account ID",
            "type": "integer"
          },
          "auth_method": {
            "enum": [
              "regular",
              "certificate",
              "entraid",
              "sso"
            ],
            "type": "string"
          },
          "bdbs_email_alerts": {
            "description": "UIDs of databases that user will receive alerts for.",
            "items": {
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "certificate_subject_line": {
            "description": "The certificate's subject line as defined by RFC2253 (for certificate based authentication users only)",
            "type": "string"
          },
          "cluster_email_alerts": {
            "description": "Activate cluster email alerts for a user.",
            "type": "boolean"
          },
          "email": {
            "description": "User's email.",
            "pattern": "(^$|^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$)",
            "type": "string"
          },
          "email_alerts": {
            "description": "Activate email alerts for a user.",
            "type": "boolean"
          },
          "name": {
            "description": "User's name. (pattern does not allow non ascii and special characters \u0026,\u003c,\u003e,\")",
            "maxLength": 255,
            "minLength": 1,
            "pattern": "^[ -!#-%'-;=?-~]+$",
            "type": "string"
          },
          "password": {
            "description": "User's password for regular authentication. Required for regular auth method.",
            "type": "string"
          },
          "password_hash_method": {
            "$ref": "#/components/schemas/PasswordHashMethod"
          },
          "role": {
            "allOf": [
              {
                "$ref": "#/components/schemas/RoleName"
              }
            ],
            "deprecated": true,
            "description": "(deprecated) User's role.",
            "x-deprecated-reason": "Use role_uids instead",
            "x-sunset": "2027-12-31"
          },
          "role_uids": {
            "description": "List of role uids associated with the user",
            "items": {
              "type": "integer",
              "x-go-type": "json.Number"
            },
            "minItems": 1,
            "type": "array",
            "uniqueItems": true
          },
          "uid": {
            "description": "User's unique uid.",
            "minimum": 1,
            "type": "integer",
            "x-go-type": "json.Number"
          }
        },
        "type": "object"
      },
      "cluster_Error": {
        "properties": {
          "description": {
            "description": "Human-readable error description",
            "type": "string"
          },
          "error_code": {
            "description": "Semantic error code",
            "type": "string"
          },
          "status_code": {
            "type": "integer",
            "x-go-json-ignore": true
          }
        },
        "required": [
          "error_code",
          "description",
          "status_code"
        ]
      },
      "database_detailed_status": {
        "default": "unknown",
        "description": "The database detailed status",
        "enum": [
          "active",
          "active-change-pending",
          "pending",
          "import-pending",
          "delete-pending",
          "recovery",
          "creation-failed",
          "unknown"
        ],
        "type": "string"
      },
      "database_status": {
        "description": "Database status",
        "enum": [
          "active",
          "warning",
          "down"
        ],
        "type": "string"
      },
      "high_availability_status": {
        "description": "The high availability status",
        "enum": [
          "down",
          "up",
          "disabled"
        ],
        "type": "string"
      },
      "replication_status": {
        "description": "The replication link status",
        "enum": [
          "down",
          "up"
        ],
        "type": "string"
      }
    },
    "securitySchemes": {
      "Auth": {
        "in": "header",
        "name": "r-auth-user",
        "type": "apiKey"
      },
      "auth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  },
  "info": {
    "description": "Redis Software REST API reference. This API reference is still a work in progress. For more API paths, see the [REST API requests](https://redis.io/docs/latest/operate/rs/references/rest-api/requests/) reference pages.",
    "title": "Redis Software REST API",
    "version": "1.0.0"
  },
  "openapi": "3.0.0",
  "paths": {
    "/v1/bdbs/certificates": {
      "get": {
        "description": "List database proxy certificates in the cluster",
        "operationId": "cluster_get_bdb_certificates",
        "parameters": [
          {
            "description": "1-based page number",
            "in": "query",
            "name": "page",
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "Number of results per page",
            "in": "query",
            "name": "page_size",
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "Return certificates that expire before the given timestamp",
            "in": "query",
            "name": "expires_before",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Filter by TLS mode. One of enabled, disabled, replica_ssl",
            "in": "query",
            "name": "tls_mode",
            "schema": {
              "enum": [
                "disabled",
                "replica_ssl",
                "enabled"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/BdbProxyCertificate"
                  },
                  "type": "array"
                }
              }
            },
            "description": "List of database proxy certificates"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "view_all_bdbs_info"
            ]
          }
        ],
        "summary": "List database proxy certificates",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/bdbs/{uid}/certificates": {
      "delete": {
        "description": "Delete database proxy certificate",
        "operationId": "cluster_delete_bdb_certificate",
        "parameters": [
          {
            "description": "The database unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Certificate deleted successfully"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "update_bdb"
            ]
          }
        ],
        "summary": "Delete database proxy certificate",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "get": {
        "description": "Get database proxy certificate",
        "operationId": "cluster_get_bdb_certificate",
        "parameters": [
          {
            "description": "The database unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BdbProxyCertificate"
                }
              }
            },
            "description": "The database proxy certificate"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "view_bdb_info"
            ]
          }
        ],
        "summary": "Get database proxy certificate",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Set or replace database proxy certificate",
        "operationId": "cluster_set_bdb_certificate",
        "parameters": [
          {
            "description": "The database unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          },
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BdbProxyCertificateSetRequest"
              }
            }
          },
          "description": "BDB proxy certificate data",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BdbProxyCertificate"
                }
              }
            },
            "description": "The updated database proxy certificate"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "update_bdb"
            ]
          }
        ],
        "summary": "Set database proxy certificate",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/bdbs/{uid}/passwords": {
      "delete": {
        "description": "Delete a password from the database's default user password list",
        "operationId": "cluster_delete_bdb_password",
        "parameters": [
          {
            "description": "The database unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "password": "password-to-delete"
              },
              "schema": {
                "$ref": "#/components/schemas/BdbPasswordRequest"
              }
            }
          },
          "description": "Password to delete",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password deleted successfully"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": [
              "update_bdb"
            ]
          }
        ],
        "summary": "Delete a password from a database's default user",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Add a new password to the database's default user password list for AUTH authentication",
        "operationId": "cluster_add_bdb_password",
        "parameters": [
          {
            "description": "The database unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "password": "new-password-to-add"
              },
              "schema": {
                "$ref": "#/components/schemas/BdbPasswordRequest"
              }
            }
          },
          "description": "Password to add",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password added successfully"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": [
              "update_bdb"
            ]
          }
        ],
        "summary": "Add a password to a database's default user",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Reset the database's default user to a single password, replacing all existing passwords",
        "operationId": "cluster_reset_bdb_password",
        "parameters": [
          {
            "description": "The database unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "password": "new-single-password"
              },
              "schema": {
                "$ref": "#/components/schemas/BdbPasswordRequest"
              }
            }
          },
          "description": "New password to set",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password reset successfully"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": [
              "update_bdb"
            ]
          }
        ],
        "summary": "Reset a database's default user password",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/cluster/certificates": {
      "get": {
        "description": "Get cluster certificates.",
        "operationId": "cluster_get_cluster_certificates",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ClusterCertificatesResponse"
                }
              }
            },
            "description": "Cluster certificates retrieved successfully."
          }
        },
        "security": [
          {
            "Auth": [
              "view_cluster_info"
            ]
          }
        ],
        "summary": "Get cluster certificates.",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Replace one or more cluster certificates and apply them across the cluster.",
        "operationId": "cluster_update_cluster_certificates",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ClusterCertificatesUpdateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Cluster certificates updated successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "update_cluster"
            ]
          }
        ],
        "summary": "Update cluster certificates.",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable",
        "x-timeout-seconds": 900
      }
    },
    "/v1/cluster/certificates/rotate": {
      "post": {
        "description": "Rotate one or more cluster certificates and apply them across the cluster.",
        "operationId": "cluster_rotate_cluster_certificates",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CertificateRotateRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Cluster certificates rotated successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "update_cluster"
            ]
          }
        ],
        "summary": "Rotate cluster certificates.",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable",
        "x-timeout-seconds": 900
      }
    },
    "/v1/cluster/certificates/{certificate_name}": {
      "delete": {
        "description": "Delete a cluster certificate by logical name.",
        "operationId": "cluster_delete_cluster_certificate",
        "parameters": [
          {
            "description": "The cluster certificate logical name.",
            "in": "path",
            "name": "certificate_name",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Cluster certificate deleted successfully."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "update_cluster"
            ]
          }
        ],
        "summary": "Delete a cluster certificate.",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/cluster/change_password_hashing_algorithm": {
      "patch": {
        "description": "Change the password hashing algorithm used for all users in the cluster.\nThis will re-hash all existing user passwords with the new algorithm.\n",
        "operationId": "cluster_change_cluster_password_hashing_algorithm",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "algorithm": "PBKDF2"
              },
              "schema": {
                "$ref": "#/components/schemas/ChangePasswordHashingAlgorithmRequest"
              }
            }
          },
          "description": "Password hashing algorithm change request",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password hashing algorithm changed successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": [
              "update_cluster"
            ]
          }
        ],
        "summary": "Change the cluster password hashing algorithm",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/cluster/ldap": {
      "delete": {
        "description": "Clear the LDAP configuration for the cluster",
        "operationId": "cluster_delete_ldap_config",
        "responses": {
          "200": {
            "description": "LDAP configuration deleted successfully."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "config_ldap"
            ]
          }
        ],
        "summary": "Delete LDAP configuration",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "get": {
        "description": "Get the LDAP configuration for the cluster",
        "operationId": "cluster_get_ldap_config",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Ldap"
                }
              }
            },
            "description": "LDAP configuration"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "view_ldap_config"
            ]
          }
        ],
        "summary": "Get LDAP configuration",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Set or partially update the LDAP configuration for the cluster",
        "operationId": "cluster_update_ldap_config",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Ldap"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Ldap"
                }
              }
            },
            "description": "LDAP configuration"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "config_ldap"
            ]
          }
        ],
        "summary": "Update LDAP configuration",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/cluster/update_cert": {
      "put": {
        "deprecated": true,
        "description": "Replace a single cluster certificate and apply it across the cluster. Deprecated, use PUT /v1/cluster/certificates.",
        "operationId": "cluster_update_cluster_cert",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ClusterCertificateUpdate"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Cluster certificate updated successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "update_cluster"
            ]
          }
        ],
        "summary": "Update a single cluster certificate.",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable",
        "x-timeout-seconds": 900
      }
    },
    "/v1/ldap_mappings": {
      "get": {
        "description": "Get all Redis Software LDAP mappings configured in the cluster.",
        "operationId": "cluster_list_ldap_mappings",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/LdapMapping"
                  },
                  "type": "array"
                }
              }
            },
            "description": "List of LDAP mappings."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        },
        "security": [
          {
            "Auth": [
              "view_all_ldap_mappings_info"
            ]
          }
        ],
        "summary": "Get all Redis Software LDAP mappings",
        "tags": [
          "LDAP Mapping"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Create a new Redis Software LDAP mapping.",
        "operationId": "cluster_create_ldap_mapping",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/LdapMappingCreateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LdapMapping"
                }
              }
            },
            "description": "LDAP mapping created successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "create_ldap_mapping"
            ]
          }
        ],
        "summary": "Create a Redis Software LDAP mapping",
        "tags": [
          "LDAP Mapping"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/ldap_mappings/{uid}": {
      "delete": {
        "description": "Delete an LDAP mapping by unique ID.",
        "operationId": "cluster_delete_ldap_mapping",
        "parameters": [
          {
            "description": "The LDAP mapping unique ID.",
            "example": 17,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "example": {
                    "action_uid": "12345-abcde-67890"
                  },
                  "properties": {
                    "action_uid": {
                      "description": "Action uid for tracking progress.",
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              }
            },
            "description": "LDAP mapping deleted successfully."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "delete_ldap_mapping"
            ]
          }
        ],
        "summary": "Delete a Redis Software LDAP mapping",
        "tags": [
          "LDAP Mapping"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "get": {
        "description": "Get a single LDAP mapping by unique ID.",
        "operationId": "cluster_get_ldap_mapping",
        "parameters": [
          {
            "description": "The LDAP mapping unique ID.",
            "example": 17,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LdapMapping"
                }
              }
            },
            "description": "LDAP mapping information."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "view_ldap_mapping_info"
            ]
          }
        ],
        "summary": "Get a single Redis Software LDAP mapping",
        "tags": [
          "LDAP Mapping"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Update an existing LDAP mapping by unique ID.",
        "operationId": "cluster_update_ldap_mapping",
        "parameters": [
          {
            "description": "The LDAP mapping unique ID.",
            "example": 17,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/LdapMappingUpdateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LdapMapping"
                }
              }
            },
            "description": "LDAP mapping updated successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "update_ldap_mapping"
            ]
          }
        ],
        "summary": "Update a Redis Software LDAP mapping",
        "tags": [
          "LDAP Mapping"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/migrations/{uid}": {
      "get": {
        "description": "Migration status of a bdb in the cluster",
        "operationId": "cluster_get_migration",
        "parameters": [
          {
            "description": "The migration unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/MigrationResponse"
                }
              }
            },
            "description": "migration information"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "view_bdb_info"
            ]
          }
        ],
        "summary": "Get migration status of a bdb in the cluster",
        "tags": [
          "Migrations"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/ocsp": {
      "get": {
        "description": "Get the OCSP configuration for the cluster",
        "operationId": "cluster_get_ocsp_config",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/OcspConfig"
                }
              }
            },
            "description": "OCSP configuration"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "view_ocsp_config"
            ]
          }
        ],
        "summary": "Get OCSP configuration",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Set or update the OCSP configuration for the cluster",
        "operationId": "cluster_update_ocsp_config",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/OcspConfig"
              }
            }
          }
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/OcspConfig"
                }
              }
            },
            "description": "OCSP configuration"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "config_ocsp"
            ]
          }
        ],
        "summary": "Update OCSP configuration",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/ocsp/status": {
      "get": {
        "description": "Get the latest OCSP status for the cluster",
        "operationId": "cluster_get_ocsp_status",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/OcspStatus"
                }
              }
            },
            "description": "OCSP status"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "view_ocsp_status"
            ]
          }
        ],
        "summary": "Get OCSP status",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/ocsp/test": {
      "post": {
        "description": "Manually query the OCSP responder and return the parsed status",
        "operationId": "cluster_test_ocsp_status",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/OcspStatus"
                }
              }
            },
            "description": "OCSP status"
          },
          "500": {
            "$ref": "#/components/responses/cluster_InternalServerError"
          }
        },
        "security": [
          {
            "Auth": [
              "test_ocsp_status"
            ]
          }
        ],
        "summary": "Test OCSP status",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/redis_acls": {
      "get": {
        "description": "Get all Redis ACLs in the cluster",
        "operationId": "cluster_get_redis_acls",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/RedisAcl"
                  },
                  "type": "array"
                }
              }
            },
            "description": "List of Redis ACLs"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        },
        "security": [
          {
            "Auth": [
              "view_all_redis_acls_info"
            ]
          }
        ],
        "summary": "Get all Redis ACLs",
        "tags": [
          "RedisAcls"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Create a new Redis ACL with the provided configuration",
        "operationId": "cluster_create_redis_acl",
        "parameters": [
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RedisAcl"
              }
            }
          },
          "description": "Redis ACL creation data",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RedisAcl"
                }
              }
            },
            "description": "Redis ACL created successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "create_redis_acl"
            ]
          }
        ],
        "summary": "Create a new Redis ACL",
        "tags": [
          "RedisAcls"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/redis_acls/validate": {
      "post": {
        "description": "Validate a Redis ACL without persisting changes. This API route is deprecated (7.12), please use POST /v1/redis_acls?dry_run instead.",
        "operationId": "cluster_validate_redis_acl",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RedisAcl"
              }
            }
          },
          "description": "Redis ACL data",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RedisAcl"
                }
              }
            },
            "description": "Redis ACL validated successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "create_redis_acl"
            ]
          }
        ],
        "summary": "Validate a Redis ACL",
        "tags": [
          "RedisAcls"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/redis_acls/{uid}": {
      "delete": {
        "description": "Delete a Redis ACL by unique ID",
        "operationId": "cluster_delete_redis_acl",
        "parameters": [
          {
            "description": "Redis ACL unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "example": {
                    "action_uid": "12345-abcde-67890"
                  },
                  "properties": {
                    "action_uid": {
                      "description": "Action uid for tracking progress",
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              }
            },
            "description": "Redis ACL deleted successfully"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "delete_redis_acl"
            ]
          }
        ],
        "summary": "Delete a Redis ACL",
        "tags": [
          "RedisAcls"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "get": {
        "description": "Get a single Redis ACL by unique ID",
        "operationId": "cluster_get_redis_acl",
        "parameters": [
          {
            "description": "Redis ACL unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RedisAcl"
                }
              }
            },
            "description": "Redis ACL"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "view_redis_acl_info"
            ]
          }
        ],
        "summary": "Get a single Redis ACL",
        "tags": [
          "RedisAcls"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Update a Redis ACL by unique ID",
        "operationId": "cluster_update_redis_acl",
        "parameters": [
          {
            "description": "Redis ACL unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          },
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RedisAcl"
              }
            }
          },
          "description": "Redis ACL update data",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RedisAcl"
                }
              }
            },
            "description": "Redis ACL updated successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "update_redis_acl"
            ]
          }
        ],
        "summary": "Update a Redis ACL",
        "tags": [
          "RedisAcls"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/roles": {
      "get": {
        "description": "Get all Redis Software roles configured in the cluster.",
        "operationId": "cluster_get_roles",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/Role"
                  },
                  "type": "array"
                }
              }
            },
            "description": "List of roles"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        },
        "security": [
          {
            "Auth": [
              "view_all_roles_info"
            ]
          }
        ],
        "summary": "Get all Redis Software roles",
        "tags": [
          "Roles"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Create a new role with the provided configuration.",
        "operationId": "cluster_create_role",
        "parameters": [
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes.",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "management": "cluster_viewer",
                "name": "Support Engineer"
              },
              "schema": {
                "$ref": "#/components/schemas/RoleCreateRequest"
              }
            }
          },
          "description": "Role creation data.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Role"
                }
              }
            },
            "description": "Role created successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/cluster_Error"
                }
              }
            },
            "description": "Role with the same name already exists."
          }
        },
        "security": [
          {
            "Auth": [
              "create_role"
            ]
          }
        ],
        "summary": "Create a new Redis Software role",
        "tags": [
          "Roles"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/roles/{uid}": {
      "delete": {
        "description": "Delete a role by unique ID.",
        "operationId": "cluster_delete_role",
        "parameters": [
          {
            "description": "The role unique ID.",
            "example": 17,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          },
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes.",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "example": {
                    "action_uid": "12345-abcde-67890"
                  },
                  "properties": {
                    "action_uid": {
                      "description": "Action uid for tracking progress.",
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              }
            },
            "description": "Role deleted successfully."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": [
              "delete_role"
            ]
          }
        ],
        "summary": "Delete a Redis Software role",
        "tags": [
          "Roles"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "get": {
        "description": "Get a single role by unique ID.",
        "operationId": "cluster_get_role",
        "parameters": [
          {
            "description": "The role unique ID.",
            "example": 17,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Role"
                }
              }
            },
            "description": "Role information."
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": [
              "view_role_info"
            ]
          }
        ],
        "summary": "Get a single Redis Software role",
        "tags": [
          "Roles"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Update a role configuration by unique ID.",
        "operationId": "cluster_update_role",
        "parameters": [
          {
            "description": "The role unique ID.",
            "example": 17,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          },
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes.",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "management": "cluster_member"
              },
              "schema": {
                "$ref": "#/components/schemas/RoleUpdateRequest"
              }
            }
          },
          "description": "Role update data.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Role"
                }
              }
            },
            "description": "Role updated successfully."
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          }
        },
        "security": [
          {
            "Auth": [
              "update_role"
            ]
          }
        ],
        "summary": "Update a Redis Software role",
        "tags": [
          "Roles"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/users": {
      "get": {
        "description": "Get all Redis Software users in the cluster",
        "operationId": "cluster_get_users",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/User"
                  },
                  "type": "array"
                }
              }
            },
            "description": "List of users"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        },
        "security": [
          {
            "Auth": [
              "view_all_users_info"
            ]
          }
        ],
        "summary": "Get all Redis Software users",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Create a new user with the provided configuration",
        "operationId": "cluster_create_user",
        "parameters": [
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/UserRequest"
              }
            }
          },
          "description": "User creation data",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            },
            "description": "User created successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/cluster_Error"
                }
              }
            },
            "description": "User with the same email or name already exists"
          }
        },
        "security": [
          {
            "Auth": [
              "create_new_user"
            ]
          }
        ],
        "summary": "Create a new Redis Software user",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/users/password": {
      "delete": {
        "description": "Delete a password from the list of a user's passwords",
        "operationId": "cluster_delete_user_password",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "old_password": "password-to-remove",
                "username": "john.doe"
              },
              "schema": {
                "properties": {
                  "old_password": {
                    "description": "An existing password to delete",
                    "type": "string"
                  },
                  "username": {
                    "description": "The username of the affected user. If missing, defaults to authenticated user",
                    "type": "string"
                  }
                },
                "required": [
                  "old_password"
                ],
                "type": "object"
              }
            }
          },
          "description": "Password deletion data",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password deleted successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Delete user password",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "post": {
        "description": "Add a new password to a user's passwords list",
        "operationId": "cluster_add_user_password",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "new_password": "additional-password",
                "username": "john.doe"
              },
              "schema": {
                "properties": {
                  "new_password": {
                    "description": "A password to add",
                    "type": "string"
                  },
                  "old_password": {
                    "deprecated": true,
                    "description": "An existing password of the user. Ignored and will be removed in 8.2.0.",
                    "type": "string"
                  },
                  "password_hash_method": {
                    "$ref": "#/components/schemas/PasswordHashMethod"
                  },
                  "username": {
                    "description": "The username of the affected user. If missing, defaults to authenticated user",
                    "type": "string"
                  }
                },
                "required": [
                  "new_password"
                ],
                "type": "object"
              }
            }
          },
          "description": "Password addition data",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password added successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Add user password",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Reset the password list of a user to include a single new password",
        "operationId": "cluster_reset_user_password",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "new_password": "new-secure-password",
                "username": "john.doe"
              },
              "schema": {
                "properties": {
                  "new_password": {
                    "description": "The new password",
                    "type": "string"
                  },
                  "old_password": {
                    "deprecated": true,
                    "description": "An existing password of the user. Ignored and will be removed in 8.2.0.",
                    "type": "string"
                  },
                  "password_hash_method": {
                    "$ref": "#/components/schemas/PasswordHashMethod"
                  },
                  "username": {
                    "description": "The username of the affected user. If missing, defaults to authenticated user",
                    "type": "string"
                  }
                },
                "required": [
                  "new_password"
                ],
                "type": "object"
              }
            }
          },
          "description": "Password reset data",
          "required": true
        },
        "responses": {
          "200": {
            "description": "Password reset successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Reset user password",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/users/permissions": {
      "get": {
        "description": "Get all management roles along with API and UI permissions",
        "operationId": "cluster_get_roles_with_permissions",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": {
                  "admin": {
                    "api_permissions": [
                      "create_node",
                      "update_node",
                      "delete_node"
                    ],
                    "ui_permissions": [
                      "view_cluster_page",
                      "view_database_page"
                    ]
                  },
                  "db_viewer": {
                    "api_permissions": [
                      "view_bdb_info",
                      "view_all_bdbs_info"
                    ],
                    "ui_permissions": [
                      "view_database_page"
                    ]
                  }
                },
                "schema": {
                  "$ref": "#/components/schemas/RolesWithPermissions"
                }
              }
            },
            "description": "Role permissions"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Get all role permissions",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/users/permissions/{role}": {
      "get": {
        "description": "Get API and UI permissions for a specific management role",
        "operationId": "cluster_get_role_with_permissions_by_role_name",
        "parameters": [
          {
            "description": "The role name",
            "example": "admin",
            "in": "path",
            "name": "role",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": {
                  "admin": {
                    "api_permissions": [
                      "create_node",
                      "update_node",
                      "delete_node"
                    ],
                    "ui_permissions": [
                      "view_cluster_page",
                      "view_database_page"
                    ]
                  }
                },
                "schema": {
                  "$ref": "#/components/schemas/RolesWithPermissions"
                }
              }
            },
            "description": "Role permissions"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Get permissions for a specific role",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/users/role": {
      "get": {
        "description": "Get the management role of the authenticating user.",
        "operationId": "cluster_get_user_role",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "role": {
                      "$ref": "#/components/schemas/RoleName"
                    }
                  },
                  "type": "object"
                }
              }
            },
            "description": "User role information"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Get the management role of the authenticating user.",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v1/users/{uid}": {
      "delete": {
        "description": "Delete a user by unique ID",
        "operationId": "cluster_delete_user",
        "parameters": [
          {
            "description": "The user unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "example": {
                    "action_uid": "12345-abcde-67890"
                  },
                  "properties": {
                    "action_uid": {
                      "description": "Action uid for tracking progress",
                      "type": "string"
                    }
                  },
                  "type": "object"
                }
              }
            },
            "description": "User deleted successfully"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": [
              "delete_user"
            ]
          }
        ],
        "summary": "Delete a Redis Software user",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "get": {
        "description": "Get a single user by unique ID",
        "operationId": "cluster_get_user",
        "parameters": [
          {
            "description": "The user unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            },
            "description": "User information"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Get a single Redis Software user",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      },
      "put": {
        "description": "Update a user configuration by unique ID",
        "operationId": "cluster_update_user",
        "parameters": [
          {
            "description": "The user unique ID",
            "example": 1,
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "integer",
              "x-go-type": "json.Number"
            }
          },
          {
            "allowEmptyValue": true,
            "description": "Validate the request without persisting changes",
            "in": "query",
            "name": "dry_run",
            "schema": {
              "type": "boolean",
              "x-go-type": "DryRun"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "email_alerts": true,
                "name": "John Doe"
              },
              "schema": {
                "$ref": "#/components/schemas/UserRequest"
              }
            }
          },
          "description": "User update data",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            },
            "description": "User updated successfully"
          },
          "400": {
            "$ref": "#/components/responses/cluster_BadRequest"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "406": {
            "$ref": "#/components/responses/NotAcceptable"
          }
        },
        "security": [
          {
            "Auth": []
          }
        ],
        "summary": "Update a Redis Software user",
        "tags": [
          "Users"
        ],
        "x-publish-docs": true,
        "x-stability-level": "stable"
      }
    },
    "/v4/cluster/health": {
      "get": {
        "description": "Cluster health report.",
        "operationId": "cluster_cluster_health_report",
        "parameters": [
          {
            "description": "indicate to return only resources with unhealthy status",
            "in": "query",
            "name": "issues_only",
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ClusterHealthReport"
                }
              }
            },
            "description": "Cluster report is ready see detailed information."
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "503": {
            "$ref": "#/components/responses/ServiceUnavailable"
          }
        },
        "security": [
          {
            "Auth": [
              "view_cluster_info"
            ]
          }
        ],
        "summary": "Get cluster health report.",
        "tags": [
          "Cluster"
        ],
        "x-publish-docs": true
      }
    },
    "/v4/db/{uid}/health": {
      "get": {
        "description": "Database health check indication.",
        "operationId": "cluster_database_health_report",
        "parameters": [
          {
            "description": "database ID",
            "in": "path",
            "name": "uid",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "indicate to return only resources with unhealthy status",
            "in": "query",
            "name": "issues_only",
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DatabaseHealthReport"
                }
              }
            },
            "description": "Database report is ready see detailed information."
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "503": {
            "$ref": "#/components/responses/ServiceUnavailable"
          }
        },
        "security": [
          {
            "Auth": [
              "view_bdb_info"
            ]
          }
        ],
        "summary": "Get database health report.",
        "tags": [
          "Database"
        ],
        "x-publish-docs": true
      }
    }
  },
  "servers": [
    {
      "url": "https://localhost:9443"
    }
  ]
}