nexus-internal.json

{
  "openapi": "3.0.3",
  "info": {
    "title": "Nexus internal API",
    "description": "Nexus internal API",
    "contact": {
      "url": "https://oxide.computer",
      "email": "api@oxide.computer"
    },
    "version": "0.0.1"
  },
  "paths": {
    "/artifacts/{kind}/{name}/{version}": {
      "get": {
        "summary": "Endpoint used by Sled Agents to download cached artifacts.",
        "operationId": "cpapi_artifact_download",
        "parameters": [
          {
            "in": "path",
            "name": "kind",
            "description": "The kind of artifact this is.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "name",
            "description": "The artifact's name.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "version",
            "description": "The artifact's version.",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/SemverVersion"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "",
            "content": {
              "*/*": {
                "schema": {}
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/bgtasks": {
      "get": {
        "summary": "List background tasks",
        "description": "This is a list of discrete background activities that Nexus carries out. This is exposed for support and debugging.",
        "operationId": "bgtask_list",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "title": "Map_of_BackgroundTask",
                  "type": "object",
                  "additionalProperties": {
                    "$ref": "#/components/schemas/BackgroundTask"
                  }
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/bgtasks/activate": {
      "post": {
        "summary": "Activates one or more background tasks, causing them to be run immediately",
        "description": "if idle, or scheduled to run again as soon as possible if already running.",
        "operationId": "bgtask_activate",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BackgroundTasksActivateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/bgtasks/view/{bgtask_name}": {
      "get": {
        "summary": "Fetch status of one background task",
        "description": "This is exposed for support and debugging.",
        "operationId": "bgtask_view",
        "parameters": [
          {
            "in": "path",
            "name": "bgtask_name",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BackgroundTask"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/clickhouse/policy": {
      "get": {
        "summary": "Get the current clickhouse policy",
        "operationId": "clickhouse_policy_get",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ClickhousePolicy"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      },
      "post": {
        "summary": "Set the new clickhouse policy",
        "operationId": "clickhouse_policy_set",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ClickhousePolicy"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/crucible/0/upstairs/{upstairs_id}/downstairs/{downstairs_id}/stop-request": {
      "post": {
        "summary": "An Upstairs will update this endpoint if a Downstairs client task is",
        "description": "requested to stop",
        "operationId": "cpapi_downstairs_client_stop_request",
        "parameters": [
          {
            "in": "path",
            "name": "downstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForDownstairsKind"
            }
          },
          {
            "in": "path",
            "name": "upstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForUpstairsKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DownstairsClientStopRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/crucible/0/upstairs/{upstairs_id}/downstairs/{downstairs_id}/stopped": {
      "post": {
        "summary": "An Upstairs will update this endpoint if a Downstairs client task stops for",
        "description": "any reason (not just after being requested to)",
        "operationId": "cpapi_downstairs_client_stopped",
        "parameters": [
          {
            "in": "path",
            "name": "downstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForDownstairsKind"
            }
          },
          {
            "in": "path",
            "name": "upstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForUpstairsKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DownstairsClientStopped"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/crucible/0/upstairs/{upstairs_id}/repair/{repair_id}/progress": {
      "post": {
        "summary": "An Upstairs will update this endpoint with the progress of a repair",
        "operationId": "cpapi_upstairs_repair_progress",
        "parameters": [
          {
            "in": "path",
            "name": "repair_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForUpstairsRepairKind"
            }
          },
          {
            "in": "path",
            "name": "upstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForUpstairsKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RepairProgress"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/crucible/0/upstairs/{upstairs_id}/repair-finish": {
      "post": {
        "summary": "An Upstairs will notify this endpoint when a repair finishes.",
        "operationId": "cpapi_upstairs_repair_finish",
        "parameters": [
          {
            "in": "path",
            "name": "upstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForUpstairsKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RepairFinishInfo"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/crucible/0/upstairs/{upstairs_id}/repair-start": {
      "post": {
        "summary": "An Upstairs will notify this endpoint when a repair starts",
        "operationId": "cpapi_upstairs_repair_start",
        "parameters": [
          {
            "in": "path",
            "name": "upstairs_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForUpstairsKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RepairStartInfo"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/demo-saga": {
      "post": {
        "summary": "Kick off an instance of the \"demo\" saga",
        "description": "This saga is used for demo and testing.  The saga just waits until you complete using the `saga_demo_complete` API.",
        "operationId": "saga_demo_create",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DemoSaga"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/demo-saga/{demo_saga_id}/complete": {
      "post": {
        "summary": "Complete a waiting demo saga",
        "description": "Note that the id used here is not the same as the id of the saga.  It's the one returned by the `saga_demo_create` API.",
        "operationId": "saga_demo_complete",
        "parameters": [
          {
            "in": "path",
            "name": "demo_saga_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForDemoSagaKind"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/deployment/blueprints/all": {
      "get": {
        "summary": "Lists blueprints",
        "operationId": "blueprint_list",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "description": "Maximum number of items returned by a single call",
            "schema": {
              "nullable": true,
              "type": "integer",
              "format": "uint32",
              "minimum": 1
            }
          },
          {
            "in": "query",
            "name": "page_token",
            "description": "Token returned by previous call to retrieve the subsequent page",
            "schema": {
              "nullable": true,
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "sort_by",
            "schema": {
              "$ref": "#/components/schemas/IdSortMode"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BlueprintMetadataResultsPage"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        },
        "x-dropshot-pagination": {
          "required": []
        }
      }
    },
    "/deployment/blueprints/all/{blueprint_id}": {
      "get": {
        "summary": "Fetches one blueprint",
        "operationId": "blueprint_view",
        "parameters": [
          {
            "in": "path",
            "name": "blueprint_id",
            "description": "ID of the blueprint",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Blueprint"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      },
      "delete": {
        "summary": "Deletes one blueprint",
        "operationId": "blueprint_delete",
        "parameters": [
          {
            "in": "path",
            "name": "blueprint_id",
            "description": "ID of the blueprint",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "successful deletion"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/deployment/blueprints/import": {
      "post": {
        "summary": "Imports a client-provided blueprint",
        "description": "This is intended for development and support, not end users or operators.",
        "operationId": "blueprint_import",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Blueprint"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/deployment/blueprints/regenerate": {
      "post": {
        "summary": "Generates a new blueprint for the current system, re-evaluating anything",
        "description": "that's changed since the last one was generated",
        "operationId": "blueprint_regenerate",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Blueprint"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/deployment/blueprints/target": {
      "get": {
        "summary": "Fetches the current target blueprint, if any",
        "operationId": "blueprint_target_view",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BlueprintTarget"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      },
      "post": {
        "summary": "Make the specified blueprint the new target",
        "operationId": "blueprint_target_set",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BlueprintTargetSet"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BlueprintTarget"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/deployment/blueprints/target/enabled": {
      "put": {
        "summary": "Set the `enabled` field of the current target blueprint",
        "operationId": "blueprint_target_set_enabled",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BlueprintTargetSet"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/BlueprintTarget"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/disk/{disk_id}/remove-read-only-parent": {
      "post": {
        "summary": "Request removal of a read_only_parent from a disk.",
        "description": "This is a thin wrapper around the volume_remove_read_only_parent saga. All we are doing here is, given a disk UUID, figure out what the volume_id is for that disk, then use that to call the disk_remove_read_only_parent saga on it.",
        "operationId": "cpapi_disk_remove_read_only_parent",
        "parameters": [
          {
            "in": "path",
            "name": "disk_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/disks/{disk_id}": {
      "put": {
        "summary": "Report updated state for a disk.",
        "operationId": "cpapi_disks_put",
        "parameters": [
          {
            "in": "path",
            "name": "disk_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DiskRuntimeState"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/instances/{instance_id}/migrate": {
      "post": {
        "operationId": "instance_migrate",
        "parameters": [
          {
            "in": "path",
            "name": "instance_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/InstanceMigrateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Instance"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/metrics/collectors": {
      "post": {
        "summary": "Accept a notification of a new oximeter collection server.",
        "operationId": "cpapi_collectors_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/OximeterInfo"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/metrics/collectors/{collector_id}/producers": {
      "get": {
        "summary": "List all metric producers assigned to an oximeter collector.",
        "operationId": "cpapi_assigned_producers_list",
        "parameters": [
          {
            "in": "path",
            "name": "collector_id",
            "description": "The ID of the oximeter collector.",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "description": "Maximum number of items returned by a single call",
            "schema": {
              "nullable": true,
              "type": "integer",
              "format": "uint32",
              "minimum": 1
            }
          },
          {
            "in": "query",
            "name": "page_token",
            "description": "Token returned by previous call to retrieve the subsequent page",
            "schema": {
              "nullable": true,
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "sort_by",
            "schema": {
              "$ref": "#/components/schemas/IdSortMode"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ProducerEndpointResultsPage"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        },
        "x-dropshot-pagination": {
          "required": []
        }
      }
    },
    "/metrics/producers": {
      "post": {
        "summary": "Accept a registration from a new metric producer",
        "operationId": "cpapi_producers_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ProducerEndpoint"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "description": "successful creation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ProducerRegistrationResponse"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/nat/ipv4/changeset/{from_gen}": {
      "get": {
        "summary": "Fetch NAT ChangeSet",
        "description": "Caller provides their generation as `from_gen`, along with a query parameter for the page size (`limit`). Endpoint will return changes that have occured since the caller's generation number up to the latest change or until the `limit` is reached. If there are no changes, an empty vec is returned.",
        "operationId": "ipv4_nat_changeset",
        "parameters": [
          {
            "in": "path",
            "name": "from_gen",
            "description": "which change number to start generating the change set from",
            "required": true,
            "schema": {
              "type": "integer",
              "format": "int64"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "required": true,
            "schema": {
              "type": "integer",
              "format": "uint32",
              "minimum": 0
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "title": "Array_of_Ipv4NatEntryView",
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Ipv4NatEntryView"
                  }
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/physical-disk/expunge": {
      "post": {
        "summary": "Mark a physical disk as expunged",
        "description": "This is an irreversible process! It should only be called after sufficient warning to the operator.\n\nThis is idempotent.",
        "operationId": "physical_disk_expunge",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PhysicalDiskPath"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/probes/{sled}": {
      "get": {
        "summary": "Get all the probes associated with a given sled.",
        "operationId": "probes_get",
        "parameters": [
          {
            "in": "path",
            "name": "sled",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          },
          {
            "in": "query",
            "name": "limit",
            "description": "Maximum number of items returned by a single call",
            "schema": {
              "nullable": true,
              "type": "integer",
              "format": "uint32",
              "minimum": 1
            }
          },
          {
            "in": "query",
            "name": "page_token",
            "description": "Token returned by previous call to retrieve the subsequent page",
            "schema": {
              "nullable": true,
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "sort_by",
            "schema": {
              "$ref": "#/components/schemas/IdSortMode"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "title": "Array_of_ProbeInfo",
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/ProbeInfo"
                  }
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        },
        "x-dropshot-pagination": {
          "required": []
        }
      }
    },
    "/racks/{rack_id}/initialization-complete": {
      "put": {
        "summary": "Report that the Rack Setup Service initialization is complete",
        "description": "See RFD 278 for more details.",
        "operationId": "rack_initialization_complete",
        "parameters": [
          {
            "in": "path",
            "name": "rack_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RackInitializationRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/sagas": {
      "get": {
        "summary": "List sagas",
        "operationId": "saga_list",
        "parameters": [
          {
            "in": "query",
            "name": "limit",
            "description": "Maximum number of items returned by a single call",
            "schema": {
              "nullable": true,
              "type": "integer",
              "format": "uint32",
              "minimum": 1
            }
          },
          {
            "in": "query",
            "name": "page_token",
            "description": "Token returned by previous call to retrieve the subsequent page",
            "schema": {
              "nullable": true,
              "type": "string"
            }
          },
          {
            "in": "query",
            "name": "sort_by",
            "schema": {
              "$ref": "#/components/schemas/IdSortMode"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SagaResultsPage"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        },
        "x-dropshot-pagination": {
          "required": []
        }
      }
    },
    "/sagas/{saga_id}": {
      "get": {
        "summary": "Fetch a saga",
        "operationId": "saga_view",
        "parameters": [
          {
            "in": "path",
            "name": "saga_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Saga"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/sled-agents/{sled_id}": {
      "get": {
        "summary": "Return information about the given sled agent",
        "operationId": "sled_agent_get",
        "parameters": [
          {
            "in": "path",
            "name": "sled_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForSledKind"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SledAgentInfo"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      },
      "post": {
        "summary": "Report that the sled agent for the specified sled has come online.",
        "operationId": "sled_agent_put",
        "parameters": [
          {
            "in": "path",
            "name": "sled_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForSledKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SledAgentInfo"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/sled-agents/{sled_id}/firewall-rules-update": {
      "post": {
        "summary": "Request a new set of firewall rules for a sled.",
        "description": "This causes Nexus to read the latest set of rules for the sled, and call a Sled endpoint which applies the rules to all OPTE ports that happen to exist.",
        "operationId": "sled_firewall_rules_request",
        "parameters": [
          {
            "in": "path",
            "name": "sled_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForSledKind"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/sleds/add": {
      "post": {
        "summary": "Add sled to initialized rack",
        "operationId": "sled_add",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/UninitializedSledId"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "description": "successful creation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SledId"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/sleds/expunge": {
      "post": {
        "summary": "Mark a sled as expunged",
        "description": "This is an irreversible process! It should only be called after sufficient warning to the operator.\n\nThis is idempotent, and it returns the old policy of the sled.",
        "operationId": "sled_expunge",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SledSelector"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SledPolicy"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/sleds/uninitialized": {
      "get": {
        "summary": "List uninitialized sleds",
        "operationId": "sled_list_uninitialized",
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UninitializedSledResultsPage"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/switch/{switch_id}": {
      "put": {
        "operationId": "switch_put",
        "parameters": [
          {
            "in": "path",
            "name": "switch_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SwitchPutRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SwitchPutResponse"
                }
              }
            }
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/vmms/{propolis_id}": {
      "put": {
        "summary": "Report updated state for a VMM.",
        "operationId": "cpapi_instances_put",
        "parameters": [
          {
            "in": "path",
            "name": "propolis_id",
            "required": true,
            "schema": {
              "$ref": "#/components/schemas/TypedUuidForPropolisKind"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SledVmmState"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    },
    "/volume/{volume_id}/remove-read-only-parent": {
      "post": {
        "summary": "Request removal of a read_only_parent from a volume.",
        "description": "A volume can be created with the source data for that volume being another volume that attached as a \"read_only_parent\". In the background there exists a scrubber that will copy the data from the read_only_parent into the volume. When that scrubber has completed copying the data, this endpoint can be called to update the database that the read_only_parent is no longer needed for a volume and future attachments of this volume should not include that read_only_parent.",
        "operationId": "cpapi_volume_remove_read_only_parent",
        "parameters": [
          {
            "in": "path",
            "name": "volume_id",
            "required": true,
            "schema": {
              "type": "string",
              "format": "uuid"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "resource updated"
          },
          "4XX": {
            "$ref": "#/components/responses/Error"
          },
          "5XX": {
            "$ref": "#/components/responses/Error"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "ActivationReason": {
        "description": "Describes why a background task was activated\n\nThis is only used for debugging.  This is deliberately not made available to the background task itself.  See \"Design notes\" in the module-level documentation for details.",
        "type": "string",
        "enum": [
          "signaled",
          "timeout",
          "dependency"
        ]
      },
      "AllowedSourceIps": {
        "description": "Description of source IPs allowed to reach rack services.",
        "oneOf": [
          {
            "description": "Allow traffic from any external IP address.",
            "type": "object",
            "properties": {
              "allow": {
                "type": "string",
                "enum": [
                  "any"
                ]
              }
            },
            "required": [
              "allow"
            ]
          },
          {
            "description": "Restrict access to a specific set of source IP addresses or subnets.\n\nAll others are prevented from reaching rack services.",
            "type": "object",
            "properties": {
              "allow": {
                "type": "string",
                "enum": [
                  "list"
                ]
              },
              "ips": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/IpNet"
                }
              }
            },
            "required": [
              "allow",
              "ips"
            ]
          }
        ]
      },
      "BackgroundTask": {
        "description": "Background tasks\n\nThese are currently only intended for observability by developers.  We will eventually want to flesh this out into something more observable for end users.",
        "type": "object",
        "properties": {
          "current": {
            "description": "Describes the current task status",
            "allOf": [
              {
                "$ref": "#/components/schemas/CurrentStatus"
              }
            ]
          },
          "description": {
            "description": "brief summary (for developers) of what this task does",
            "type": "string"
          },
          "last": {
            "description": "Describes the last completed activation",
            "allOf": [
              {
                "$ref": "#/components/schemas/LastResult"
              }
            ]
          },
          "name": {
            "description": "unique identifier for this background task",
            "type": "string"
          },
          "period": {
            "description": "how long after an activation completes before another will be triggered automatically\n\n(activations can also be triggered for other reasons)",
            "allOf": [
              {
                "$ref": "#/components/schemas/Duration"
              }
            ]
          }
        },
        "required": [
          "current",
          "description",
          "last",
          "name",
          "period"
        ]
      },
      "BackgroundTasksActivateRequest": {
        "description": "Query parameters for Background Task activation requests.",
        "type": "object",
        "properties": {
          "bgtask_names": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "uniqueItems": true
          }
        },
        "required": [
          "bgtask_names"
        ]
      },
      "Baseboard": {
        "description": "Properties that uniquely identify an Oxide hardware component",
        "type": "object",
        "properties": {
          "part": {
            "type": "string"
          },
          "revision": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "serial": {
            "type": "string"
          }
        },
        "required": [
          "part",
          "revision",
          "serial"
        ]
      },
      "BfdMode": {
        "description": "BFD connection mode.",
        "type": "string",
        "enum": [
          "single_hop",
          "multi_hop"
        ]
      },
      "BfdPeerConfig": {
        "type": "object",
        "properties": {
          "detection_threshold": {
            "type": "integer",
            "format": "uint8",
            "minimum": 0
          },
          "local": {
            "nullable": true,
            "type": "string",
            "format": "ip"
          },
          "mode": {
            "$ref": "#/components/schemas/BfdMode"
          },
          "remote": {
            "type": "string",
            "format": "ip"
          },
          "required_rx": {
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "switch": {
            "$ref": "#/components/schemas/SwitchLocation"
          }
        },
        "required": [
          "detection_threshold",
          "mode",
          "remote",
          "required_rx",
          "switch"
        ]
      },
      "BgpConfig": {
        "type": "object",
        "properties": {
          "asn": {
            "description": "The autonomous system number for the BGP configuration.",
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "checker": {
            "nullable": true,
            "description": "Checker to apply to incoming messages.",
            "default": null,
            "type": "string"
          },
          "originate": {
            "description": "The set of prefixes for the BGP router to originate.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Ipv4Net"
            }
          },
          "shaper": {
            "nullable": true,
            "description": "Shaper to apply to outgoing messages.",
            "default": null,
            "type": "string"
          }
        },
        "required": [
          "asn",
          "originate"
        ]
      },
      "BgpPeerConfig": {
        "type": "object",
        "properties": {
          "addr": {
            "description": "Address of the peer.",
            "type": "string",
            "format": "ipv4"
          },
          "allowed_export": {
            "description": "Define export policy for a peer.",
            "default": {
              "type": "no_filtering"
            },
            "allOf": [
              {
                "$ref": "#/components/schemas/ImportExportPolicy"
              }
            ]
          },
          "allowed_import": {
            "description": "Define import policy for a peer.",
            "default": {
              "type": "no_filtering"
            },
            "allOf": [
              {
                "$ref": "#/components/schemas/ImportExportPolicy"
              }
            ]
          },
          "asn": {
            "description": "The autonomous system number of the router the peer belongs to.",
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "communities": {
            "description": "Include the provided communities in updates sent to the peer.",
            "default": [],
            "type": "array",
            "items": {
              "type": "integer",
              "format": "uint32",
              "minimum": 0
            }
          },
          "connect_retry": {
            "nullable": true,
            "description": "The interval in seconds between peer connection retry attempts.",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "delay_open": {
            "nullable": true,
            "description": "How long to delay sending open messages to a peer. In seconds.",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "enforce_first_as": {
            "description": "Enforce that the first AS in paths received from this peer is the peer's AS.",
            "default": false,
            "type": "boolean"
          },
          "hold_time": {
            "nullable": true,
            "description": "How long to keep a session alive without a keepalive in seconds. Defaults to 6.",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "idle_hold_time": {
            "nullable": true,
            "description": "How long to keep a peer in idle after a state machine reset in seconds.",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "keepalive": {
            "nullable": true,
            "description": "The interval to send keepalive messages at.",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "local_pref": {
            "nullable": true,
            "description": "Apply a local preference to routes received from this peer.",
            "default": null,
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "md5_auth_key": {
            "nullable": true,
            "description": "Use the given key for TCP-MD5 authentication with the peer.",
            "default": null,
            "type": "string"
          },
          "min_ttl": {
            "nullable": true,
            "description": "Require messages from a peer have a minimum IP time to live field.",
            "default": null,
            "type": "integer",
            "format": "uint8",
            "minimum": 0
          },
          "multi_exit_discriminator": {
            "nullable": true,
            "description": "Apply the provided multi-exit discriminator (MED) updates sent to the peer.",
            "default": null,
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "port": {
            "description": "Switch port the peer is reachable on.",
            "type": "string"
          },
          "remote_asn": {
            "nullable": true,
            "description": "Require that a peer has a specified ASN.",
            "default": null,
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "vlan_id": {
            "nullable": true,
            "description": "Associate a VLAN ID with a BGP peer session.",
            "default": null,
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          }
        },
        "required": [
          "addr",
          "asn",
          "port"
        ]
      },
      "Blueprint": {
        "description": "Describes a complete set of software and configuration for the system",
        "type": "object",
        "properties": {
          "blueprint_datasets": {
            "description": "A map of sled id -> datasets in use on each sled",
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/BlueprintDatasetsConfig"
            }
          },
          "blueprint_disks": {
            "description": "A map of sled id -> disks in use on each sled.",
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/BlueprintPhysicalDisksConfig"
            }
          },
          "blueprint_zones": {
            "description": "A map of sled id -> zones deployed on each sled, along with the [`BlueprintZoneDisposition`] for each zone.\n\nUnlike `sled_state`, this map may contain entries for sleds that are no longer a part of the control plane cluster (e.g., sleds that have been decommissioned, but still have expunged zones where cleanup has not yet completed).",
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/BlueprintZonesConfig"
            }
          },
          "clickhouse_cluster_config": {
            "nullable": true,
            "description": "Allocation of Clickhouse Servers and Keepers for replicated clickhouse setups. This is set to `None` if replicated clickhouse is not in use.",
            "allOf": [
              {
                "$ref": "#/components/schemas/ClickhouseClusterConfig"
              }
            ]
          },
          "cockroachdb_fingerprint": {
            "description": "CockroachDB state fingerprint when this blueprint was created",
            "type": "string"
          },
          "cockroachdb_setting_preserve_downgrade": {
            "description": "Whether to set `cluster.preserve_downgrade_option` and what to set it to",
            "allOf": [
              {
                "$ref": "#/components/schemas/CockroachDbPreserveDowngrade"
              }
            ]
          },
          "comment": {
            "description": "human-readable string describing why this blueprint was created (for debugging)",
            "type": "string"
          },
          "creator": {
            "description": "identity of the component that generated the blueprint (for debugging) This would generally be the Uuid of a Nexus instance.",
            "type": "string"
          },
          "external_dns_version": {
            "description": "external DNS version when thi blueprint was created",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "id": {
            "description": "unique identifier for this blueprint",
            "type": "string",
            "format": "uuid"
          },
          "internal_dns_version": {
            "description": "internal DNS version when this blueprint was created",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "parent_blueprint_id": {
            "nullable": true,
            "description": "which blueprint this blueprint is based on",
            "type": "string",
            "format": "uuid"
          },
          "sled_state": {
            "description": "A map of sled id -> desired state of the sled.\n\nA sled is considered part of the control plane cluster iff it has an entry in this map.",
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/SledState"
            }
          },
          "time_created": {
            "description": "when this blueprint was generated (for debugging)",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "blueprint_datasets",
          "blueprint_disks",
          "blueprint_zones",
          "cockroachdb_fingerprint",
          "cockroachdb_setting_preserve_downgrade",
          "comment",
          "creator",
          "external_dns_version",
          "id",
          "internal_dns_version",
          "sled_state",
          "time_created"
        ]
      },
      "BlueprintDatasetConfig": {
        "description": "Information about a dataset as recorded in a blueprint",
        "type": "object",
        "properties": {
          "address": {
            "nullable": true,
            "type": "string"
          },
          "compression": {
            "$ref": "#/components/schemas/CompressionAlgorithm"
          },
          "disposition": {
            "$ref": "#/components/schemas/BlueprintDatasetDisposition"
          },
          "id": {
            "$ref": "#/components/schemas/TypedUuidForDatasetKind"
          },
          "kind": {
            "$ref": "#/components/schemas/DatasetKind"
          },
          "pool": {
            "$ref": "#/components/schemas/ZpoolName"
          },
          "quota": {
            "nullable": true,
            "allOf": [
              {
                "$ref": "#/components/schemas/ByteCount"
              }
            ]
          },
          "reservation": {
            "nullable": true,
            "allOf": [
              {
                "$ref": "#/components/schemas/ByteCount"
              }
            ]
          }
        },
        "required": [
          "compression",
          "disposition",
          "id",
          "kind",
          "pool"
        ]
      },
      "BlueprintDatasetDisposition": {
        "description": "The desired state of an Omicron-managed dataset in a blueprint.\n\nPart of [`BlueprintDatasetConfig`].",
        "oneOf": [
          {
            "description": "The dataset is in-service.",
            "type": "string",
            "enum": [
              "in_service"
            ]
          },
          {
            "description": "The dataset is permanently gone.",
            "type": "string",
            "enum": [
              "expunged"
            ]
          }
        ]
      },
      "BlueprintDatasetsConfig": {
        "description": "Information about Omicron datasets as recorded in a blueprint.",
        "type": "object",
        "properties": {
          "datasets": {
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/BlueprintDatasetConfig"
            }
          },
          "generation": {
            "$ref": "#/components/schemas/Generation"
          }
        },
        "required": [
          "datasets",
          "generation"
        ]
      },
      "BlueprintMetadata": {
        "description": "Describe high-level metadata about a blueprint",
        "type": "object",
        "properties": {
          "cockroachdb_fingerprint": {
            "description": "CockroachDB state fingerprint when this blueprint was created",
            "type": "string"
          },
          "cockroachdb_setting_preserve_downgrade": {
            "nullable": true,
            "description": "Whether to set `cluster.preserve_downgrade_option` and what to set it to (`None` if this value was retrieved from the database and was invalid)",
            "allOf": [
              {
                "$ref": "#/components/schemas/CockroachDbPreserveDowngrade"
              }
            ]
          },
          "comment": {
            "description": "human-readable string describing why this blueprint was created (for debugging)",
            "type": "string"
          },
          "creator": {
            "description": "identity of the component that generated the blueprint (for debugging) This would generally be the Uuid of a Nexus instance.",
            "type": "string"
          },
          "external_dns_version": {
            "description": "external DNS version when this blueprint was created",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "id": {
            "description": "unique identifier for this blueprint",
            "type": "string",
            "format": "uuid"
          },
          "internal_dns_version": {
            "description": "internal DNS version when this blueprint was created",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "parent_blueprint_id": {
            "nullable": true,
            "description": "which blueprint this blueprint is based on",
            "type": "string",
            "format": "uuid"
          },
          "time_created": {
            "description": "when this blueprint was generated (for debugging)",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "cockroachdb_fingerprint",
          "comment",
          "creator",
          "external_dns_version",
          "id",
          "internal_dns_version",
          "time_created"
        ]
      },
      "BlueprintMetadataResultsPage": {
        "description": "A single page of results",
        "type": "object",
        "properties": {
          "items": {
            "description": "list of items on this page of results",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/BlueprintMetadata"
            }
          },
          "next_page": {
            "nullable": true,
            "description": "token used to fetch the next page of results (if any)",
            "type": "string"
          }
        },
        "required": [
          "items"
        ]
      },
      "BlueprintPhysicalDiskConfig": {
        "description": "Information about an Omicron physical disk as recorded in a bluerprint.",
        "type": "object",
        "properties": {
          "disposition": {
            "$ref": "#/components/schemas/BlueprintPhysicalDiskDisposition"
          },
          "id": {
            "$ref": "#/components/schemas/TypedUuidForPhysicalDiskKind"
          },
          "identity": {
            "$ref": "#/components/schemas/DiskIdentity"
          },
          "pool_id": {
            "$ref": "#/components/schemas/TypedUuidForZpoolKind"
          }
        },
        "required": [
          "disposition",
          "id",
          "identity",
          "pool_id"
        ]
      },
      "BlueprintPhysicalDiskDisposition": {
        "description": "The desired state of an Omicron-managed physical disk in a blueprint.",
        "oneOf": [
          {
            "description": "The physical disk is in-service.",
            "type": "string",
            "enum": [
              "in_service"
            ]
          },
          {
            "description": "The physical disk is permanently gone.",
            "type": "string",
            "enum": [
              "expunged"
            ]
          }
        ]
      },
      "BlueprintPhysicalDisksConfig": {
        "description": "Information about Omicron physical disks as recorded in a blueprint.\n\nPart of [`Blueprint`].",
        "type": "object",
        "properties": {
          "disks": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/BlueprintPhysicalDiskConfig"
            }
          },
          "generation": {
            "$ref": "#/components/schemas/Generation"
          }
        },
        "required": [
          "disks",
          "generation"
        ]
      },
      "BlueprintTarget": {
        "description": "Describes what blueprint, if any, the system is currently working toward",
        "type": "object",
        "properties": {
          "enabled": {
            "description": "policy: should the system actively work towards this blueprint\n\nThis should generally be left enabled.",
            "type": "boolean"
          },
          "target_id": {
            "description": "id of the blueprint that the system is trying to make real",
            "type": "string",
            "format": "uuid"
          },
          "time_made_target": {
            "description": "when this blueprint was made the target",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "enabled",
          "target_id",
          "time_made_target"
        ]
      },
      "BlueprintTargetSet": {
        "description": "Specifies what blueprint, if any, the system should be working toward",
        "type": "object",
        "properties": {
          "enabled": {
            "type": "boolean"
          },
          "target_id": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "enabled",
          "target_id"
        ]
      },
      "BlueprintZoneConfig": {
        "description": "Describes one Omicron-managed zone in a blueprint.\n\nPart of [`BlueprintZonesConfig`].",
        "type": "object",
        "properties": {
          "disposition": {
            "description": "The disposition (desired state) of this zone recorded in the blueprint.",
            "allOf": [
              {
                "$ref": "#/components/schemas/BlueprintZoneDisposition"
              }
            ]
          },
          "filesystem_pool": {
            "nullable": true,
            "description": "zpool used for the zone's (transient) root filesystem",
            "allOf": [
              {
                "$ref": "#/components/schemas/ZpoolName"
              }
            ]
          },
          "id": {
            "$ref": "#/components/schemas/TypedUuidForOmicronZoneKind"
          },
          "zone_type": {
            "$ref": "#/components/schemas/BlueprintZoneType"
          }
        },
        "required": [
          "disposition",
          "id",
          "zone_type"
        ]
      },
      "BlueprintZoneDisposition": {
        "description": "The desired state of an Omicron-managed zone in a blueprint.\n\nPart of [`BlueprintZoneConfig`].",
        "oneOf": [
          {
            "description": "The zone is in-service.",
            "type": "string",
            "enum": [
              "in_service"
            ]
          },
          {
            "description": "The zone is not in service.",
            "type": "string",
            "enum": [
              "quiesced"
            ]
          },
          {
            "description": "The zone is permanently gone.",
            "type": "string",
            "enum": [
              "expunged"
            ]
          }
        ]
      },
      "BlueprintZoneType": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "dns_servers": {
                "type": "array",
                "items": {
                  "type": "string",
                  "format": "ip"
                }
              },
              "domain": {
                "nullable": true,
                "type": "string"
              },
              "external_ip": {
                "$ref": "#/components/schemas/OmicronZoneExternalSnatIp"
              },
              "nic": {
                "description": "The service vNIC providing outbound connectivity using OPTE.",
                "allOf": [
                  {
                    "$ref": "#/components/schemas/NetworkInterface"
                  }
                ]
              },
              "ntp_servers": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "type": {
                "type": "string",
                "enum": [
                  "boundary_ntp"
                ]
              }
            },
            "required": [
              "address",
              "dns_servers",
              "external_ip",
              "nic",
              "ntp_servers",
              "type"
            ]
          },
          {
            "description": "Used in single-node clickhouse setups",
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "type": {
                "type": "string",
                "enum": [
                  "clickhouse"
                ]
              }
            },
            "required": [
              "address",
              "dataset",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "type": {
                "type": "string",
                "enum": [
                  "clickhouse_keeper"
                ]
              }
            },
            "required": [
              "address",
              "dataset",
              "type"
            ]
          },
          {
            "description": "Used in replicated clickhouse setups",
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "type": {
                "type": "string",
                "enum": [
                  "clickhouse_server"
                ]
              }
            },
            "required": [
              "address",
              "dataset",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "type": {
                "type": "string",
                "enum": [
                  "cockroach_db"
                ]
              }
            },
            "required": [
              "address",
              "dataset",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "type": {
                "type": "string",
                "enum": [
                  "crucible"
                ]
              }
            },
            "required": [
              "address",
              "dataset",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "crucible_pantry"
                ]
              }
            },
            "required": [
              "address",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "dns_address": {
                "description": "The address at which the external DNS server is reachable.",
                "allOf": [
                  {
                    "$ref": "#/components/schemas/OmicronZoneExternalFloatingAddr"
                  }
                ]
              },
              "http_address": {
                "description": "The address at which the external DNS server API is reachable.",
                "type": "string"
              },
              "nic": {
                "description": "The service vNIC providing external connectivity using OPTE.",
                "allOf": [
                  {
                    "$ref": "#/components/schemas/NetworkInterface"
                  }
                ]
              },
              "type": {
                "type": "string",
                "enum": [
                  "external_dns"
                ]
              }
            },
            "required": [
              "dataset",
              "dns_address",
              "http_address",
              "nic",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "dataset": {
                "$ref": "#/components/schemas/OmicronZoneDataset"
              },
              "dns_address": {
                "type": "string"
              },
              "gz_address": {
                "description": "The addresses in the global zone which should be created\n\nFor the DNS service, which exists outside the sleds's typical subnet - adding an address in the GZ is necessary to allow inter-zone traffic routing.",
                "type": "string",
                "format": "ipv6"
              },
              "gz_address_index": {
                "description": "The address is also identified with an auxiliary bit of information to ensure that the created global zone address can have a unique name.",
                "type": "integer",
                "format": "uint32",
                "minimum": 0
              },
              "http_address": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "internal_dns"
                ]
              }
            },
            "required": [
              "dataset",
              "dns_address",
              "gz_address",
              "gz_address_index",
              "http_address",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "internal_ntp"
                ]
              }
            },
            "required": [
              "address",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "external_dns_servers": {
                "description": "External DNS servers Nexus can use to resolve external hosts.",
                "type": "array",
                "items": {
                  "type": "string",
                  "format": "ip"
                }
              },
              "external_ip": {
                "description": "The address at which the external nexus server is reachable.",
                "allOf": [
                  {
                    "$ref": "#/components/schemas/OmicronZoneExternalFloatingIp"
                  }
                ]
              },
              "external_tls": {
                "description": "Whether Nexus's external endpoint should use TLS",
                "type": "boolean"
              },
              "internal_address": {
                "description": "The address at which the internal nexus server is reachable.",
                "type": "string"
              },
              "nic": {
                "description": "The service vNIC providing external connectivity using OPTE.",
                "allOf": [
                  {
                    "$ref": "#/components/schemas/NetworkInterface"
                  }
                ]
              },
              "type": {
                "type": "string",
                "enum": [
                  "nexus"
                ]
              }
            },
            "required": [
              "external_dns_servers",
              "external_ip",
              "external_tls",
              "internal_address",
              "nic",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "address": {
                "type": "string"
              },
              "type": {
                "type": "string",
                "enum": [
                  "oximeter"
                ]
              }
            },
            "required": [
              "address",
              "type"
            ]
          }
        ]
      },
      "BlueprintZonesConfig": {
        "description": "Information about an Omicron zone as recorded in a blueprint.\n\nCurrently, this is similar to [`OmicronZonesConfig`], but also contains a per-zone [`BlueprintZoneDisposition`].\n\nPart of [`Blueprint`].",
        "type": "object",
        "properties": {
          "generation": {
            "description": "Generation number of this configuration.\n\nThis generation number is owned by the control plane. See [`OmicronZonesConfig::generation`] for more details.",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "zones": {
            "description": "The list of running zones.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/BlueprintZoneConfig"
            }
          }
        },
        "required": [
          "generation",
          "zones"
        ]
      },
      "ByteCount": {
        "description": "Byte count to express memory or storage capacity.",
        "type": "integer",
        "format": "uint64",
        "minimum": 0
      },
      "Certificate": {
        "type": "object",
        "properties": {
          "cert": {
            "type": "string"
          },
          "key": {
            "type": "string"
          }
        },
        "required": [
          "cert",
          "key"
        ]
      },
      "ClickhouseClusterConfig": {
        "description": "Global configuration for all clickhouse servers (replicas) and keepers",
        "type": "object",
        "properties": {
          "cluster_name": {
            "description": "An arbitrary name for the Clickhouse cluster shared by all nodes",
            "type": "string"
          },
          "cluster_secret": {
            "description": "An arbitrary string shared by all nodes used at runtime to determine whether nodes are part of the same cluster.",
            "type": "string"
          },
          "generation": {
            "description": "The last update to the clickhouse cluster configuration\n\nThis is used by `clickhouse-admin` in the clickhouse server and keeper zones to discard old configurations.",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "highest_seen_keeper_leader_committed_log_index": {
            "description": "This is used as a marker to tell if the raft configuration in a new inventory collection is newer than the last collection. This serves as a surrogate for the log index of the last committed configuration, which clickhouse keeper doesn't expose.\n\nThis is necesssary because during inventory collection we poll multiple keeper nodes, and each returns their local knowledge of the configuration. But we may reach different nodes in different attempts, and some nodes in a following attempt may reflect stale configuration. Due to timing, we can always query old information. That is just normal polling. However, we never want to use old configuration if we have already seen and acted on newer configuration.",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "keepers": {
            "description": "The desired state of the clickhouse keeper cluster\n\nWe decouple deployment of zones that should contain clickhouse keeper processes from actually starting or stopping those processes, adding or removing them to/from the keeper cluster, and reconfiguring other keeper and clickhouse server nodes to reflect the new configuration.\n\nAs part of this decoupling, we keep track of the intended zone deployment in the blueprint, but that is not enough to track the desired state of the keeper cluster. We are only allowed to add or remove one keeper node at a time, and therefore we must track the desired state of the keeper cluster which may change multiple times until the keepers in the cluster match the deployed zones. An example may help:\n\n1. We start with 3 keeper nodes in 3 deployed keeper zones and need to add two to reach our desired policy of 5 keepers 2. The planner adds 2 new keeper zones to the blueprint 3. The planner will also add **one** new keeper to the `keepers` field below that matches one of the deployed zones. 4. The executor will start the new keeper process that was added to the `keepers` field, attempt to add it to the keeper cluster by pushing configuration updates to the other keepers, and then updating the clickhouse server configurations to know about the new keeper. 5. If the keeper is successfully added, as reflected in inventory, then steps 3 and 4 above will be repeated for the next keeper process. 6. If the keeper is not successfully added by the executor it will continue to retry indefinitely. 7. If the zone is expunged while the planner has it as part of its desired state in `keepers`, and the executor is trying to add it, the keeper will be removed from `keepers` in the next blueprint. If it has been added to the actual cluster by an executor in the meantime it will be removed on the next iteration of an executor.",
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/KeeperId"
            }
          },
          "max_used_keeper_id": {
            "description": "Clickhouse Keeper IDs must be unique and are handed out monotonically. Keep track of the last used one.",
            "allOf": [
              {
                "$ref": "#/components/schemas/KeeperId"
              }
            ]
          },
          "max_used_server_id": {
            "description": "Clickhouse Server IDs must be unique and are handed out monotonically. Keep track of the last used one.",
            "allOf": [
              {
                "$ref": "#/components/schemas/ServerId"
              }
            ]
          },
          "servers": {
            "description": "The desired state of clickhouse server processes on the rack\n\nClickhouse servers do not have the same limitations as keepers and can be deployed all at once.",
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/ServerId"
            }
          }
        },
        "required": [
          "cluster_name",
          "cluster_secret",
          "generation",
          "highest_seen_keeper_leader_committed_log_index",
          "keepers",
          "max_used_keeper_id",
          "max_used_server_id",
          "servers"
        ]
      },
      "ClickhouseMode": {
        "description": "How to deploy clickhouse nodes",
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "single_node_only"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "cluster_only"
                ]
              },
              "value": {
                "type": "object",
                "properties": {
                  "target_keepers": {
                    "type": "integer",
                    "format": "uint8",
                    "minimum": 0
                  },
                  "target_servers": {
                    "type": "integer",
                    "format": "uint8",
                    "minimum": 0
                  }
                },
                "required": [
                  "target_keepers",
                  "target_servers"
                ]
              }
            },
            "required": [
              "type",
              "value"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "both"
                ]
              },
              "value": {
                "type": "object",
                "properties": {
                  "target_keepers": {
                    "type": "integer",
                    "format": "uint8",
                    "minimum": 0
                  },
                  "target_servers": {
                    "type": "integer",
                    "format": "uint8",
                    "minimum": 0
                  }
                },
                "required": [
                  "target_keepers",
                  "target_servers"
                ]
              }
            },
            "required": [
              "type",
              "value"
            ]
          }
        ]
      },
      "ClickhousePolicy": {
        "type": "object",
        "properties": {
          "mode": {
            "$ref": "#/components/schemas/ClickhouseMode"
          },
          "time_created": {
            "type": "string",
            "format": "date-time"
          },
          "version": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          }
        },
        "required": [
          "mode",
          "time_created",
          "version"
        ]
      },
      "CockroachDbClusterVersion": {
        "description": "CockroachDB cluster versions we are aware of.\n\nCockroachDB can be upgraded from one major version to the next, e.g. v22.1 -> v22.2. Each major version introduces changes in how it stores data on disk to support new features, and each major version has support for reading the previous version's data so that it can perform an upgrade. The version of the data format is called the \"cluster version\", which is distinct from but related to the software version that's being run.\n\nWhile software version v22.2 is using cluster version v22.1, it's possible to downgrade back to v22.1. Once the cluster version is upgraded, there's no going back.\n\nTo give us some time to evaluate new versions of the software while retaining a downgrade path, we currently deploy new versions of CockroachDB across two releases of the Oxide software, in a \"tick-tock\" model:\n\n- In \"tick\" releases, we upgrade the version of the CockroachDB software to a new major version, and update `CockroachDbClusterVersion::NEWLY_INITIALIZED`. On upgraded racks, the new version is running with the previous cluster version; on newly-initialized racks, the new version is running with the new cluser version. - In \"tock\" releases, we change `CockroachDbClusterVersion::POLICY` to the major version we upgraded to in the last \"tick\" release. This results in a new blueprint that upgrades the cluster version, destroying the downgrade path but allowing us to eventually upgrade to the next release.\n\nThese presently describe major versions of CockroachDB. The order of these must be maintained in the correct order (the first variant must be the earliest version).",
        "type": "string",
        "enum": [
          "V22_1"
        ]
      },
      "CockroachDbPreserveDowngrade": {
        "description": "Whether to set `cluster.preserve_downgrade_option` and what to set it to.",
        "oneOf": [
          {
            "description": "Do not modify the setting.",
            "type": "object",
            "properties": {
              "action": {
                "type": "string",
                "enum": [
                  "do_not_modify"
                ]
              }
            },
            "required": [
              "action"
            ]
          },
          {
            "description": "Ensure the setting is set to an empty string.",
            "type": "object",
            "properties": {
              "action": {
                "type": "string",
                "enum": [
                  "allow_upgrade"
                ]
              }
            },
            "required": [
              "action"
            ]
          },
          {
            "description": "Ensure the setting is set to a given cluster version.",
            "type": "object",
            "properties": {
              "action": {
                "type": "string",
                "enum": [
                  "set"
                ]
              },
              "data": {
                "$ref": "#/components/schemas/CockroachDbClusterVersion"
              }
            },
            "required": [
              "action",
              "data"
            ]
          }
        ]
      },
      "CompressionAlgorithm": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "on"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "off"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "gzip"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "level": {
                "$ref": "#/components/schemas/GzipLevel"
              },
              "type": {
                "type": "string",
                "enum": [
                  "gzip_n"
                ]
              }
            },
            "required": [
              "level",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "lz4"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "lzjb"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "zle"
                ]
              }
            },
            "required": [
              "type"
            ]
          }
        ]
      },
      "CurrentStatus": {
        "description": "Describes the current status of a background task",
        "oneOf": [
          {
            "description": "The background task is not running\n\nTypically, the task would be waiting for its next activation, which would happen after a timeout or some other event that triggers activation",
            "type": "object",
            "properties": {
              "current_status": {
                "type": "string",
                "enum": [
                  "idle"
                ]
              }
            },
            "required": [
              "current_status"
            ]
          },
          {
            "description": "The background task is currently running\n\nMore precisely, the task has been activated and has not yet finished this activation",
            "type": "object",
            "properties": {
              "current_status": {
                "type": "string",
                "enum": [
                  "running"
                ]
              },
              "details": {
                "$ref": "#/components/schemas/CurrentStatusRunning"
              }
            },
            "required": [
              "current_status",
              "details"
            ]
          }
        ]
      },
      "CurrentStatusRunning": {
        "type": "object",
        "properties": {
          "iteration": {
            "description": "which iteration this was (counter)",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "reason": {
            "description": "what kind of event triggered this activation",
            "allOf": [
              {
                "$ref": "#/components/schemas/ActivationReason"
              }
            ]
          },
          "start_time": {
            "description": "wall-clock time when the current activation started",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "iteration",
          "reason",
          "start_time"
        ]
      },
      "DatasetCreateRequest": {
        "type": "object",
        "properties": {
          "dataset_id": {
            "$ref": "#/components/schemas/TypedUuidForDatasetKind"
          },
          "request": {
            "$ref": "#/components/schemas/DatasetPutRequest"
          },
          "zpool_id": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "dataset_id",
          "request",
          "zpool_id"
        ]
      },
      "DatasetKind": {
        "description": "The kind of dataset. See the `DatasetKind` enum in omicron-common for possible values.",
        "type": "string"
      },
      "DatasetPutRequest": {
        "description": "Describes a dataset within a pool.",
        "type": "object",
        "properties": {
          "address": {
            "nullable": true,
            "description": "Address on which a service is responding to requests for the dataset.",
            "type": "string"
          },
          "kind": {
            "description": "Type of dataset being inserted.",
            "allOf": [
              {
                "$ref": "#/components/schemas/DatasetKind"
              }
            ]
          }
        },
        "required": [
          "kind"
        ]
      },
      "DemoSaga": {
        "description": "Identifies an instance of the demo saga",
        "type": "object",
        "properties": {
          "demo_saga_id": {
            "$ref": "#/components/schemas/TypedUuidForDemoSagaKind"
          },
          "saga_id": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "demo_saga_id",
          "saga_id"
        ]
      },
      "DiskIdentity": {
        "description": "Uniquely identifies a disk.",
        "type": "object",
        "properties": {
          "model": {
            "type": "string"
          },
          "serial": {
            "type": "string"
          },
          "vendor": {
            "type": "string"
          }
        },
        "required": [
          "model",
          "serial",
          "vendor"
        ]
      },
      "DiskRuntimeState": {
        "description": "Runtime state of the Disk, which includes its attach state and some minimal metadata",
        "type": "object",
        "properties": {
          "disk_state": {
            "description": "runtime state of the Disk",
            "allOf": [
              {
                "$ref": "#/components/schemas/DiskState"
              }
            ]
          },
          "gen": {
            "description": "generation number for this state",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "time_updated": {
            "description": "timestamp for this information",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "disk_state",
          "gen",
          "time_updated"
        ]
      },
      "DiskState": {
        "description": "State of a Disk",
        "oneOf": [
          {
            "description": "Disk is being initialized",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "creating"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is ready but detached from any Instance",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "detached"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is ready to receive blocks from an external source",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "import_ready"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is importing blocks from a URL",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "importing_from_url"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is importing blocks from bulk writes",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "importing_from_bulk_writes"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is being finalized to state Detached",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "finalizing"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is undergoing maintenance",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "maintenance"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is being attached to the given Instance",
            "type": "object",
            "properties": {
              "instance": {
                "type": "string",
                "format": "uuid"
              },
              "state": {
                "type": "string",
                "enum": [
                  "attaching"
                ]
              }
            },
            "required": [
              "instance",
              "state"
            ]
          },
          {
            "description": "Disk is attached to the given Instance",
            "type": "object",
            "properties": {
              "instance": {
                "type": "string",
                "format": "uuid"
              },
              "state": {
                "type": "string",
                "enum": [
                  "attached"
                ]
              }
            },
            "required": [
              "instance",
              "state"
            ]
          },
          {
            "description": "Disk is being detached from the given Instance",
            "type": "object",
            "properties": {
              "instance": {
                "type": "string",
                "format": "uuid"
              },
              "state": {
                "type": "string",
                "enum": [
                  "detaching"
                ]
              }
            },
            "required": [
              "instance",
              "state"
            ]
          },
          {
            "description": "Disk has been destroyed",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "destroyed"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Disk is unavailable",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "faulted"
                ]
              }
            },
            "required": [
              "state"
            ]
          }
        ]
      },
      "DnsConfigParams": {
        "type": "object",
        "properties": {
          "generation": {
            "$ref": "#/components/schemas/Generation"
          },
          "time_created": {
            "type": "string",
            "format": "date-time"
          },
          "zones": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/DnsConfigZone"
            }
          }
        },
        "required": [
          "generation",
          "time_created",
          "zones"
        ]
      },
      "DnsConfigZone": {
        "type": "object",
        "properties": {
          "records": {
            "type": "object",
            "additionalProperties": {
              "type": "array",
              "items": {
                "$ref": "#/components/schemas/DnsRecord"
              }
            }
          },
          "zone_name": {
            "type": "string"
          }
        },
        "required": [
          "records",
          "zone_name"
        ]
      },
      "DnsRecord": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "data": {
                "type": "string",
                "format": "ipv4"
              },
              "type": {
                "type": "string",
                "enum": [
                  "A"
                ]
              }
            },
            "required": [
              "data",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "data": {
                "type": "string",
                "format": "ipv6"
              },
              "type": {
                "type": "string",
                "enum": [
                  "AAAA"
                ]
              }
            },
            "required": [
              "data",
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "data": {
                "$ref": "#/components/schemas/Srv"
              },
              "type": {
                "type": "string",
                "enum": [
                  "SRV"
                ]
              }
            },
            "required": [
              "data",
              "type"
            ]
          }
        ]
      },
      "DownstairsClientStopRequest": {
        "type": "object",
        "properties": {
          "reason": {
            "$ref": "#/components/schemas/DownstairsClientStopRequestReason"
          },
          "time": {
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "reason",
          "time"
        ]
      },
      "DownstairsClientStopRequestReason": {
        "type": "string",
        "enum": [
          "replacing",
          "disabled",
          "failed_reconcile",
          "i_o_error",
          "bad_negotiation_order",
          "incompatible",
          "failed_live_repair",
          "too_many_outstanding_jobs",
          "deactivated"
        ]
      },
      "DownstairsClientStopped": {
        "type": "object",
        "properties": {
          "reason": {
            "$ref": "#/components/schemas/DownstairsClientStoppedReason"
          },
          "time": {
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "reason",
          "time"
        ]
      },
      "DownstairsClientStoppedReason": {
        "type": "string",
        "enum": [
          "connection_timeout",
          "connection_failed",
          "timeout",
          "write_failed",
          "read_failed",
          "requested_stop",
          "finished",
          "queue_closed",
          "receive_task_cancelled"
        ]
      },
      "DownstairsUnderRepair": {
        "type": "object",
        "properties": {
          "region_uuid": {
            "$ref": "#/components/schemas/TypedUuidForDownstairsRegionKind"
          },
          "target_addr": {
            "type": "string"
          }
        },
        "required": [
          "region_uuid",
          "target_addr"
        ]
      },
      "Duration": {
        "type": "object",
        "properties": {
          "nanos": {
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "secs": {
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          }
        },
        "required": [
          "nanos",
          "secs"
        ]
      },
      "Error": {
        "description": "Error information from a response.",
        "type": "object",
        "properties": {
          "error_code": {
            "type": "string"
          },
          "message": {
            "type": "string"
          },
          "request_id": {
            "type": "string"
          }
        },
        "required": [
          "message",
          "request_id"
        ]
      },
      "ExternalPortDiscovery": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "auto": {
                "type": "object",
                "additionalProperties": {
                  "type": "string",
                  "format": "ipv6"
                }
              }
            },
            "required": [
              "auto"
            ],
            "additionalProperties": false
          },
          {
            "type": "object",
            "properties": {
              "static": {
                "type": "object",
                "additionalProperties": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Name"
                  }
                }
              }
            },
            "required": [
              "static"
            ],
            "additionalProperties": false
          }
        ]
      },
      "Generation": {
        "description": "Generation numbers stored in the database, used for optimistic concurrency control",
        "type": "integer",
        "format": "uint64",
        "minimum": 0
      },
      "GzipLevel": {
        "type": "integer",
        "format": "uint8",
        "minimum": 0
      },
      "ImportExportPolicy": {
        "description": "Define policy relating to the import and export of prefixes from a BGP peer.",
        "oneOf": [
          {
            "description": "Do not perform any filtering.",
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "no_filtering"
                ]
              }
            },
            "required": [
              "type"
            ]
          },
          {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "allow"
                ]
              },
              "value": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/IpNet"
                }
              }
            },
            "required": [
              "type",
              "value"
            ]
          }
        ]
      },
      "Instance": {
        "description": "View of an Instance",
        "type": "object",
        "properties": {
          "auto_restart_cooldown_expiration": {
            "nullable": true,
            "description": "The time at which the auto-restart cooldown period for this instance completes, permitting it to be automatically restarted again. If the instance enters the `Failed` state, it will not be restarted until after this time.\n\nIf this is not present, then either the instance has never been automatically restarted, or the cooldown period has already expired, allowing the instance to be restarted immediately if it fails.",
            "type": "string",
            "format": "date-time"
          },
          "auto_restart_enabled": {
            "description": "`true` if this instance's auto-restart policy will permit the control plane to automatically restart it if it enters the `Failed` state.",
            "type": "boolean"
          },
          "auto_restart_policy": {
            "nullable": true,
            "description": "The auto-restart policy configured for this instance, or `null` if no explicit policy has been configured.\n\nThis policy determines whether the instance should be automatically restarted by the control plane on failure. If this is `null`, the control plane will use the default policy when determining whether or not to automatically restart this instance, which may or may not allow it to be restarted. The value of the `auto_restart_enabled` field indicates whether the instance will be auto-restarted, based on its current policy or the default if it has no configured policy.",
            "allOf": [
              {
                "$ref": "#/components/schemas/InstanceAutoRestartPolicy"
              }
            ]
          },
          "boot_disk_id": {
            "nullable": true,
            "description": "the ID of the disk used to boot this Instance, if a specific one is assigned.",
            "type": "string",
            "format": "uuid"
          },
          "description": {
            "description": "human-readable free-form text about a resource",
            "type": "string"
          },
          "hostname": {
            "description": "RFC1035-compliant hostname for the Instance.",
            "type": "string"
          },
          "id": {
            "description": "unique, immutable, system-controlled identifier for each resource",
            "type": "string",
            "format": "uuid"
          },
          "memory": {
            "description": "memory allocated for this Instance",
            "allOf": [
              {
                "$ref": "#/components/schemas/ByteCount"
              }
            ]
          },
          "name": {
            "description": "unique, mutable, user-controlled identifier for each resource",
            "allOf": [
              {
                "$ref": "#/components/schemas/Name"
              }
            ]
          },
          "ncpus": {
            "description": "number of CPUs allocated for this Instance",
            "allOf": [
              {
                "$ref": "#/components/schemas/InstanceCpuCount"
              }
            ]
          },
          "project_id": {
            "description": "id for the project containing this Instance",
            "type": "string",
            "format": "uuid"
          },
          "run_state": {
            "$ref": "#/components/schemas/InstanceState"
          },
          "time_created": {
            "description": "timestamp when this resource was created",
            "type": "string",
            "format": "date-time"
          },
          "time_last_auto_restarted": {
            "nullable": true,
            "description": "The timestamp of the most recent time this instance was automatically restarted by the control plane.\n\nIf this is not present, then this instance has not been automatically restarted.",
            "type": "string",
            "format": "date-time"
          },
          "time_modified": {
            "description": "timestamp when this resource was last modified",
            "type": "string",
            "format": "date-time"
          },
          "time_run_state_updated": {
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "auto_restart_enabled",
          "description",
          "hostname",
          "id",
          "memory",
          "name",
          "ncpus",
          "project_id",
          "run_state",
          "time_created",
          "time_modified",
          "time_run_state_updated"
        ]
      },
      "InstanceAutoRestartPolicy": {
        "description": "A policy determining when an instance should be automatically restarted by the control plane.",
        "oneOf": [
          {
            "description": "The instance should not be automatically restarted by the control plane if it fails.",
            "type": "string",
            "enum": [
              "never"
            ]
          },
          {
            "description": "If this instance is running and unexpectedly fails (e.g. due to a host software crash or unexpected host reboot), the control plane will make a best-effort attempt to restart it. The control plane may choose not to restart the instance to preserve the overall availability of the system.",
            "type": "string",
            "enum": [
              "best_effort"
            ]
          }
        ]
      },
      "InstanceCpuCount": {
        "description": "The number of CPUs in an Instance",
        "type": "integer",
        "format": "uint16",
        "minimum": 0
      },
      "InstanceMigrateRequest": {
        "description": "Parameters used when migrating an instance.",
        "type": "object",
        "properties": {
          "dst_sled_id": {
            "description": "The ID of the sled to which to migrate the target instance.",
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "dst_sled_id"
        ]
      },
      "InstanceState": {
        "description": "Running state of an Instance (primarily: booted or stopped)\n\nThis typically reflects whether it's starting, running, stopping, or stopped, but also includes states related to the Instance's lifecycle",
        "oneOf": [
          {
            "description": "The instance is being created.",
            "type": "string",
            "enum": [
              "creating"
            ]
          },
          {
            "description": "The instance is currently starting up.",
            "type": "string",
            "enum": [
              "starting"
            ]
          },
          {
            "description": "The instance is currently running.",
            "type": "string",
            "enum": [
              "running"
            ]
          },
          {
            "description": "The instance has been requested to stop and a transition to \"Stopped\" is imminent.",
            "type": "string",
            "enum": [
              "stopping"
            ]
          },
          {
            "description": "The instance is currently stopped.",
            "type": "string",
            "enum": [
              "stopped"
            ]
          },
          {
            "description": "The instance is in the process of rebooting - it will remain in the \"rebooting\" state until the VM is starting once more.",
            "type": "string",
            "enum": [
              "rebooting"
            ]
          },
          {
            "description": "The instance is in the process of migrating - it will remain in the \"migrating\" state until the migration process is complete and the destination propolis is ready to continue execution.",
            "type": "string",
            "enum": [
              "migrating"
            ]
          },
          {
            "description": "The instance is attempting to recover from a failure.",
            "type": "string",
            "enum": [
              "repairing"
            ]
          },
          {
            "description": "The instance has encountered a failure.",
            "type": "string",
            "enum": [
              "failed"
            ]
          },
          {
            "description": "The instance has been deleted.",
            "type": "string",
            "enum": [
              "destroyed"
            ]
          }
        ]
      },
      "IpNet": {
        "x-rust-type": {
          "crate": "oxnet",
          "path": "oxnet::IpNet",
          "version": "0.1.0"
        },
        "oneOf": [
          {
            "title": "v4",
            "allOf": [
              {
                "$ref": "#/components/schemas/Ipv4Net"
              }
            ]
          },
          {
            "title": "v6",
            "allOf": [
              {
                "$ref": "#/components/schemas/Ipv6Net"
              }
            ]
          }
        ]
      },
      "IpRange": {
        "oneOf": [
          {
            "title": "v4",
            "allOf": [
              {
                "$ref": "#/components/schemas/Ipv4Range"
              }
            ]
          },
          {
            "title": "v6",
            "allOf": [
              {
                "$ref": "#/components/schemas/Ipv6Range"
              }
            ]
          }
        ]
      },
      "Ipv4NatEntryView": {
        "description": "NAT Record",
        "type": "object",
        "properties": {
          "deleted": {
            "type": "boolean"
          },
          "external_address": {
            "type": "string",
            "format": "ipv4"
          },
          "first_port": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "gen": {
            "type": "integer",
            "format": "int64"
          },
          "last_port": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "mac": {
            "$ref": "#/components/schemas/MacAddr"
          },
          "sled_address": {
            "type": "string",
            "format": "ipv6"
          },
          "vni": {
            "$ref": "#/components/schemas/Vni"
          }
        },
        "required": [
          "deleted",
          "external_address",
          "first_port",
          "gen",
          "last_port",
          "mac",
          "sled_address",
          "vni"
        ]
      },
      "Ipv4Net": {
        "example": "192.168.1.0/24",
        "title": "An IPv4 subnet",
        "description": "An IPv4 subnet, including prefix and prefix length",
        "x-rust-type": {
          "crate": "oxnet",
          "path": "oxnet::Ipv4Net",
          "version": "0.1.0"
        },
        "type": "string",
        "pattern": "^(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])/([0-9]|1[0-9]|2[0-9]|3[0-2])$"
      },
      "Ipv4Range": {
        "description": "A non-decreasing IPv4 address range, inclusive of both ends.\n\nThe first address must be less than or equal to the last address.",
        "type": "object",
        "properties": {
          "first": {
            "type": "string",
            "format": "ipv4"
          },
          "last": {
            "type": "string",
            "format": "ipv4"
          }
        },
        "required": [
          "first",
          "last"
        ]
      },
      "Ipv6Net": {
        "example": "fd12:3456::/64",
        "title": "An IPv6 subnet",
        "description": "An IPv6 subnet, including prefix and subnet mask",
        "x-rust-type": {
          "crate": "oxnet",
          "path": "oxnet::Ipv6Net",
          "version": "0.1.0"
        },
        "type": "string",
        "pattern": "^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/([0-9]|[1-9][0-9]|1[0-1][0-9]|12[0-8])$"
      },
      "Ipv6Range": {
        "description": "A non-decreasing IPv6 address range, inclusive of both ends.\n\nThe first address must be less than or equal to the last address.",
        "type": "object",
        "properties": {
          "first": {
            "type": "string",
            "format": "ipv6"
          },
          "last": {
            "type": "string",
            "format": "ipv6"
          }
        },
        "required": [
          "first",
          "last"
        ]
      },
      "KeeperId": {
        "description": "A unique ID for a ClickHouse Keeper",
        "type": "integer",
        "format": "uint64",
        "minimum": 0
      },
      "LastResult": {
        "oneOf": [
          {
            "description": "The task has never completed an activation",
            "type": "object",
            "properties": {
              "last_result": {
                "type": "string",
                "enum": [
                  "never_completed"
                ]
              }
            },
            "required": [
              "last_result"
            ]
          },
          {
            "description": "The task has completed at least one activation",
            "type": "object",
            "properties": {
              "details": {
                "$ref": "#/components/schemas/LastResultCompleted"
              },
              "last_result": {
                "type": "string",
                "enum": [
                  "completed"
                ]
              }
            },
            "required": [
              "details",
              "last_result"
            ]
          }
        ]
      },
      "LastResultCompleted": {
        "type": "object",
        "properties": {
          "details": {
            "description": "arbitrary datum emitted by the background task"
          },
          "elapsed": {
            "description": "total time elapsed during the activation",
            "allOf": [
              {
                "$ref": "#/components/schemas/Duration"
              }
            ]
          },
          "iteration": {
            "description": "which iteration this was (counter)",
            "type": "integer",
            "format": "uint64",
            "minimum": 0
          },
          "reason": {
            "description": "what kind of event triggered this activation",
            "allOf": [
              {
                "$ref": "#/components/schemas/ActivationReason"
              }
            ]
          },
          "start_time": {
            "description": "wall-clock time when the activation started",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "details",
          "elapsed",
          "iteration",
          "reason",
          "start_time"
        ]
      },
      "LldpAdminStatus": {
        "description": "To what extent should this port participate in LLDP",
        "type": "string",
        "enum": [
          "enabled",
          "disabled",
          "rx_only",
          "tx_only"
        ]
      },
      "LldpPortConfig": {
        "description": "Per-port LLDP configuration settings.  Only the \"status\" setting is mandatory.  All other fields have natural defaults or may be inherited from the switch.",
        "type": "object",
        "properties": {
          "chassis_id": {
            "nullable": true,
            "description": "Chassis ID to advertise.  If this is set, it will be advertised as a LocallyAssigned ID type.  If this is not set, it will be inherited from the switch-level settings.",
            "type": "string"
          },
          "management_addrs": {
            "nullable": true,
            "description": "Management IP addresses to advertise.  If this is not set, it will be inherited from the switch-level settings.",
            "type": "array",
            "items": {
              "type": "string",
              "format": "ip"
            }
          },
          "port_description": {
            "nullable": true,
            "description": "Port description to advertise.  If this is not set, no description will be advertised.",
            "type": "string"
          },
          "port_id": {
            "nullable": true,
            "description": "Port ID to advertise.  If this is set, it will be advertised as a LocallyAssigned ID type.  If this is not set, it will be set to the port name. e.g., qsfp0/0.",
            "type": "string"
          },
          "status": {
            "description": "To what extent should this port participate in LLDP",
            "allOf": [
              {
                "$ref": "#/components/schemas/LldpAdminStatus"
              }
            ]
          },
          "system_description": {
            "nullable": true,
            "description": "System description to advertise.  If this is not set, it will be inherited from the switch-level settings.",
            "type": "string"
          },
          "system_name": {
            "nullable": true,
            "description": "System name to advertise.  If this is not set, it will be inherited from the switch-level settings.",
            "type": "string"
          }
        },
        "required": [
          "status"
        ]
      },
      "MacAddr": {
        "example": "ff:ff:ff:ff:ff:ff",
        "title": "A MAC address",
        "description": "A Media Access Control address, in EUI-48 format",
        "type": "string",
        "pattern": "^([0-9a-fA-F]{0,2}:){5}[0-9a-fA-F]{0,2}$",
        "minLength": 5,
        "maxLength": 17
      },
      "MigrationRuntimeState": {
        "description": "An update from a sled regarding the state of a migration, indicating the role of the VMM whose migration state was updated.",
        "type": "object",
        "properties": {
          "gen": {
            "$ref": "#/components/schemas/Generation"
          },
          "migration_id": {
            "type": "string",
            "format": "uuid"
          },
          "state": {
            "$ref": "#/components/schemas/MigrationState"
          },
          "time_updated": {
            "description": "Timestamp for the migration state update.",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "gen",
          "migration_id",
          "state",
          "time_updated"
        ]
      },
      "MigrationState": {
        "description": "The state of an instance's live migration.",
        "oneOf": [
          {
            "description": "The migration has not started for this VMM.",
            "type": "string",
            "enum": [
              "pending"
            ]
          },
          {
            "description": "The migration is in progress.",
            "type": "string",
            "enum": [
              "in_progress"
            ]
          },
          {
            "description": "The migration has failed.",
            "type": "string",
            "enum": [
              "failed"
            ]
          },
          {
            "description": "The migration has completed.",
            "type": "string",
            "enum": [
              "completed"
            ]
          }
        ]
      },
      "Name": {
        "title": "A name unique within the parent collection",
        "description": "Names must begin with a lower case ASCII letter, be composed exclusively of lowercase ASCII, uppercase ASCII, numbers, and '-', and may not end with a '-'. Names cannot be a UUID, but they may contain a UUID. They can be at most 63 characters long.",
        "type": "string",
        "pattern": "^(?![0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$)^[a-z]([a-zA-Z0-9-]*[a-zA-Z0-9]+)?$",
        "minLength": 1,
        "maxLength": 63
      },
      "NetworkInterface": {
        "description": "Information required to construct a virtual network interface",
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "format": "uuid"
          },
          "ip": {
            "type": "string",
            "format": "ip"
          },
          "kind": {
            "$ref": "#/components/schemas/NetworkInterfaceKind"
          },
          "mac": {
            "$ref": "#/components/schemas/MacAddr"
          },
          "name": {
            "$ref": "#/components/schemas/Name"
          },
          "primary": {
            "type": "boolean"
          },
          "slot": {
            "type": "integer",
            "format": "uint8",
            "minimum": 0
          },
          "subnet": {
            "$ref": "#/components/schemas/IpNet"
          },
          "transit_ips": {
            "default": [],
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/IpNet"
            }
          },
          "vni": {
            "$ref": "#/components/schemas/Vni"
          }
        },
        "required": [
          "id",
          "ip",
          "kind",
          "mac",
          "name",
          "primary",
          "slot",
          "subnet",
          "vni"
        ]
      },
      "NetworkInterfaceKind": {
        "description": "The type of network interface",
        "oneOf": [
          {
            "description": "A vNIC attached to a guest instance",
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "format": "uuid"
              },
              "type": {
                "type": "string",
                "enum": [
                  "instance"
                ]
              }
            },
            "required": [
              "id",
              "type"
            ]
          },
          {
            "description": "A vNIC associated with an internal service",
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "format": "uuid"
              },
              "type": {
                "type": "string",
                "enum": [
                  "service"
                ]
              }
            },
            "required": [
              "id",
              "type"
            ]
          },
          {
            "description": "A vNIC associated with a probe",
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "format": "uuid"
              },
              "type": {
                "type": "string",
                "enum": [
                  "probe"
                ]
              }
            },
            "required": [
              "id",
              "type"
            ]
          }
        ]
      },
      "NewPasswordHash": {
        "title": "A password hash in PHC string format",
        "description": "Password hashes must be in PHC (Password Hashing Competition) string format.  Passwords must be hashed with Argon2id.  Password hashes may be rejected if the parameters appear not to be secure enough.",
        "type": "string"
      },
      "NodeName": {
        "description": "Unique name for a saga [`Node`]\n\nEach node requires a string name that's unique within its DAG.  The name is used to identify its output.  Nodes that depend on a given node (either directly or indirectly) can access the node's output using its name.",
        "type": "string"
      },
      "OmicronZoneDataset": {
        "description": "Describes a persistent ZFS dataset associated with an Omicron zone",
        "type": "object",
        "properties": {
          "pool_name": {
            "$ref": "#/components/schemas/ZpoolName"
          }
        },
        "required": [
          "pool_name"
        ]
      },
      "OmicronZoneExternalFloatingAddr": {
        "description": "Floating external address with port allocated to an Omicron-managed zone.",
        "type": "object",
        "properties": {
          "addr": {
            "type": "string"
          },
          "id": {
            "$ref": "#/components/schemas/TypedUuidForExternalIpKind"
          }
        },
        "required": [
          "addr",
          "id"
        ]
      },
      "OmicronZoneExternalFloatingIp": {
        "description": "Floating external IP allocated to an Omicron-managed zone.\n\nThis is a slimmer `nexus_db_model::ExternalIp` that only stores the fields necessary for blueprint planning, and requires that the zone have a single IP.",
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/TypedUuidForExternalIpKind"
          },
          "ip": {
            "type": "string",
            "format": "ip"
          }
        },
        "required": [
          "id",
          "ip"
        ]
      },
      "OmicronZoneExternalSnatIp": {
        "description": "SNAT (outbound) external IP allocated to an Omicron-managed zone.\n\nThis is a slimmer `nexus_db_model::ExternalIp` that only stores the fields necessary for blueprint planning, and requires that the zone have a single IP.",
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/TypedUuidForExternalIpKind"
          },
          "snat_cfg": {
            "$ref": "#/components/schemas/SourceNatConfig"
          }
        },
        "required": [
          "id",
          "snat_cfg"
        ]
      },
      "OximeterInfo": {
        "description": "Message used to notify Nexus that this oximeter instance is up and running.",
        "type": "object",
        "properties": {
          "address": {
            "description": "The address on which this oximeter instance listens for requests",
            "type": "string"
          },
          "collector_id": {
            "description": "The ID for this oximeter instance.",
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "address",
          "collector_id"
        ]
      },
      "PhysicalDiskKind": {
        "description": "Describes the form factor of physical disks.",
        "type": "string",
        "enum": [
          "m2",
          "u2"
        ]
      },
      "PhysicalDiskPath": {
        "type": "object",
        "properties": {
          "disk_id": {
            "description": "ID of the physical disk",
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "disk_id"
        ]
      },
      "PhysicalDiskPutRequest": {
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/TypedUuidForPhysicalDiskKind"
          },
          "model": {
            "type": "string"
          },
          "serial": {
            "type": "string"
          },
          "sled_id": {
            "type": "string",
            "format": "uuid"
          },
          "variant": {
            "$ref": "#/components/schemas/PhysicalDiskKind"
          },
          "vendor": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "model",
          "serial",
          "sled_id",
          "variant",
          "vendor"
        ]
      },
      "PortConfigV2": {
        "type": "object",
        "properties": {
          "addresses": {
            "description": "This port's addresses and optional vlan IDs",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/UplinkAddressConfig"
            }
          },
          "autoneg": {
            "description": "Whether or not to set autonegotiation",
            "default": false,
            "type": "boolean"
          },
          "bgp_peers": {
            "description": "BGP peers on this port",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/BgpPeerConfig"
            }
          },
          "lldp": {
            "nullable": true,
            "description": "LLDP configuration for this port",
            "allOf": [
              {
                "$ref": "#/components/schemas/LldpPortConfig"
              }
            ]
          },
          "port": {
            "description": "Nmae of the port this config applies to.",
            "type": "string"
          },
          "routes": {
            "description": "The set of routes associated with this port.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/RouteConfig"
            }
          },
          "switch": {
            "description": "Switch the port belongs to.",
            "allOf": [
              {
                "$ref": "#/components/schemas/SwitchLocation"
              }
            ]
          },
          "tx_eq": {
            "nullable": true,
            "description": "TX-EQ configuration for this port",
            "allOf": [
              {
                "$ref": "#/components/schemas/TxEqConfig"
              }
            ]
          },
          "uplink_port_fec": {
            "nullable": true,
            "description": "Port forward error correction type.",
            "allOf": [
              {
                "$ref": "#/components/schemas/PortFec"
              }
            ]
          },
          "uplink_port_speed": {
            "description": "Port speed.",
            "allOf": [
              {
                "$ref": "#/components/schemas/PortSpeed"
              }
            ]
          }
        },
        "required": [
          "addresses",
          "bgp_peers",
          "port",
          "routes",
          "switch",
          "uplink_port_speed"
        ]
      },
      "PortFec": {
        "description": "Switchport FEC options",
        "type": "string",
        "enum": [
          "firecode",
          "none",
          "rs"
        ]
      },
      "PortSpeed": {
        "description": "Switchport Speed options",
        "type": "string",
        "enum": [
          "speed0_g",
          "speed1_g",
          "speed10_g",
          "speed25_g",
          "speed40_g",
          "speed50_g",
          "speed100_g",
          "speed200_g",
          "speed400_g"
        ]
      },
      "ProbeExternalIp": {
        "type": "object",
        "properties": {
          "first_port": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "ip": {
            "type": "string",
            "format": "ip"
          },
          "kind": {
            "$ref": "#/components/schemas/ProbeExternalIpKind"
          },
          "last_port": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          }
        },
        "required": [
          "first_port",
          "ip",
          "kind",
          "last_port"
        ]
      },
      "ProbeExternalIpKind": {
        "type": "string",
        "enum": [
          "snat",
          "floating",
          "ephemeral"
        ]
      },
      "ProbeInfo": {
        "type": "object",
        "properties": {
          "external_ips": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ProbeExternalIp"
            }
          },
          "id": {
            "type": "string",
            "format": "uuid"
          },
          "interface": {
            "$ref": "#/components/schemas/NetworkInterface"
          },
          "name": {
            "$ref": "#/components/schemas/Name"
          },
          "sled": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "external_ips",
          "id",
          "interface",
          "name",
          "sled"
        ]
      },
      "ProducerEndpoint": {
        "description": "Information announced by a metric server, used so that clients can contact it and collect available metric data from it.",
        "type": "object",
        "properties": {
          "address": {
            "description": "The IP address and port at which `oximeter` can collect metrics from the producer.",
            "type": "string"
          },
          "id": {
            "description": "A unique ID for this producer.",
            "type": "string",
            "format": "uuid"
          },
          "interval": {
            "description": "The interval on which `oximeter` should collect metrics.",
            "allOf": [
              {
                "$ref": "#/components/schemas/Duration"
              }
            ]
          },
          "kind": {
            "description": "The kind of producer.",
            "allOf": [
              {
                "$ref": "#/components/schemas/ProducerKind"
              }
            ]
          }
        },
        "required": [
          "address",
          "id",
          "interval",
          "kind"
        ]
      },
      "ProducerEndpointResultsPage": {
        "description": "A single page of results",
        "type": "object",
        "properties": {
          "items": {
            "description": "list of items on this page of results",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ProducerEndpoint"
            }
          },
          "next_page": {
            "nullable": true,
            "description": "token used to fetch the next page of results (if any)",
            "type": "string"
          }
        },
        "required": [
          "items"
        ]
      },
      "ProducerKind": {
        "description": "The kind of metric producer this is.",
        "oneOf": [
          {
            "description": "The producer is a sled-agent.",
            "type": "string",
            "enum": [
              "sled_agent"
            ]
          },
          {
            "description": "The producer is an Omicron-managed service.",
            "type": "string",
            "enum": [
              "service"
            ]
          },
          {
            "description": "The producer is a Propolis VMM managing a guest instance.",
            "type": "string",
            "enum": [
              "instance"
            ]
          },
          {
            "description": "The producer is a management gateway service.",
            "type": "string",
            "enum": [
              "management_gateway"
            ]
          }
        ]
      },
      "ProducerRegistrationResponse": {
        "description": "Response to a successful producer registration.",
        "type": "object",
        "properties": {
          "lease_duration": {
            "description": "Period within which producers must renew their lease.\n\nProducers are required to periodically re-register with Nexus, to ensure that they are still collected from by `oximeter`.",
            "allOf": [
              {
                "$ref": "#/components/schemas/Duration"
              }
            ]
          }
        },
        "required": [
          "lease_duration"
        ]
      },
      "RackInitializationRequest": {
        "type": "object",
        "properties": {
          "allowed_source_ips": {
            "description": "IPs or subnets allowed to make requests to user-facing services",
            "allOf": [
              {
                "$ref": "#/components/schemas/AllowedSourceIps"
              }
            ]
          },
          "blueprint": {
            "description": "Blueprint describing services initialized by RSS.",
            "allOf": [
              {
                "$ref": "#/components/schemas/Blueprint"
              }
            ]
          },
          "certs": {
            "description": "x.509 Certificates used to encrypt communication with the external API.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Certificate"
            }
          },
          "datasets": {
            "description": "Datasets on the rack which have been provisioned by RSS.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/DatasetCreateRequest"
            }
          },
          "external_dns_zone_name": {
            "description": "delegated DNS name for external DNS",
            "type": "string"
          },
          "external_port_count": {
            "description": "The external qsfp ports per sidecar",
            "allOf": [
              {
                "$ref": "#/components/schemas/ExternalPortDiscovery"
              }
            ]
          },
          "internal_dns_zone_config": {
            "description": "initial internal DNS config",
            "allOf": [
              {
                "$ref": "#/components/schemas/DnsConfigParams"
              }
            ]
          },
          "internal_services_ip_pool_ranges": {
            "description": "Ranges of the service IP pool which may be used for internal services, such as Nexus.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/IpRange"
            }
          },
          "physical_disks": {
            "description": "\"Managed\" physical disks owned by the control plane",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/PhysicalDiskPutRequest"
            }
          },
          "rack_network_config": {
            "description": "Initial rack network configuration",
            "allOf": [
              {
                "$ref": "#/components/schemas/RackNetworkConfigV2"
              }
            ]
          },
          "recovery_silo": {
            "description": "configuration for the initial (recovery) Silo",
            "allOf": [
              {
                "$ref": "#/components/schemas/RecoverySiloConfig"
              }
            ]
          },
          "zpools": {
            "description": "Zpools created within the physical disks created by the control plane.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ZpoolPutRequest"
            }
          }
        },
        "required": [
          "allowed_source_ips",
          "blueprint",
          "certs",
          "datasets",
          "external_dns_zone_name",
          "external_port_count",
          "internal_dns_zone_config",
          "internal_services_ip_pool_ranges",
          "physical_disks",
          "rack_network_config",
          "recovery_silo",
          "zpools"
        ]
      },
      "RackNetworkConfigV2": {
        "description": "Initial network configuration",
        "type": "object",
        "properties": {
          "bfd": {
            "description": "BFD configuration for connecting the rack to external networks",
            "default": [],
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/BfdPeerConfig"
            }
          },
          "bgp": {
            "description": "BGP configurations for connecting the rack to external networks",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/BgpConfig"
            }
          },
          "infra_ip_first": {
            "description": "First ip address to be used for configuring network infrastructure",
            "type": "string",
            "format": "ipv4"
          },
          "infra_ip_last": {
            "description": "Last ip address to be used for configuring network infrastructure",
            "type": "string",
            "format": "ipv4"
          },
          "ports": {
            "description": "Uplinks for connecting the rack to external networks",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/PortConfigV2"
            }
          },
          "rack_subnet": {
            "$ref": "#/components/schemas/Ipv6Net"
          }
        },
        "required": [
          "bgp",
          "infra_ip_first",
          "infra_ip_last",
          "ports",
          "rack_subnet"
        ]
      },
      "RecoverySiloConfig": {
        "type": "object",
        "properties": {
          "silo_name": {
            "$ref": "#/components/schemas/Name"
          },
          "user_name": {
            "$ref": "#/components/schemas/UserId"
          },
          "user_password_hash": {
            "$ref": "#/components/schemas/NewPasswordHash"
          }
        },
        "required": [
          "silo_name",
          "user_name",
          "user_password_hash"
        ]
      },
      "RepairFinishInfo": {
        "type": "object",
        "properties": {
          "aborted": {
            "type": "boolean"
          },
          "repair_id": {
            "$ref": "#/components/schemas/TypedUuidForUpstairsRepairKind"
          },
          "repair_type": {
            "$ref": "#/components/schemas/UpstairsRepairType"
          },
          "repairs": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/DownstairsUnderRepair"
            }
          },
          "session_id": {
            "$ref": "#/components/schemas/TypedUuidForUpstairsSessionKind"
          },
          "time": {
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "aborted",
          "repair_id",
          "repair_type",
          "repairs",
          "session_id",
          "time"
        ]
      },
      "RepairProgress": {
        "type": "object",
        "properties": {
          "current_item": {
            "type": "integer",
            "format": "int64"
          },
          "time": {
            "type": "string",
            "format": "date-time"
          },
          "total_items": {
            "type": "integer",
            "format": "int64"
          }
        },
        "required": [
          "current_item",
          "time",
          "total_items"
        ]
      },
      "RepairStartInfo": {
        "type": "object",
        "properties": {
          "repair_id": {
            "$ref": "#/components/schemas/TypedUuidForUpstairsRepairKind"
          },
          "repair_type": {
            "$ref": "#/components/schemas/UpstairsRepairType"
          },
          "repairs": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/DownstairsUnderRepair"
            }
          },
          "session_id": {
            "$ref": "#/components/schemas/TypedUuidForUpstairsSessionKind"
          },
          "time": {
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "repair_id",
          "repair_type",
          "repairs",
          "session_id",
          "time"
        ]
      },
      "RouteConfig": {
        "type": "object",
        "properties": {
          "destination": {
            "description": "The destination of the route.",
            "allOf": [
              {
                "$ref": "#/components/schemas/IpNet"
              }
            ]
          },
          "nexthop": {
            "description": "The nexthop/gateway address.",
            "type": "string",
            "format": "ip"
          },
          "rib_priority": {
            "nullable": true,
            "description": "The RIB priority (i.e. Admin Distance) associated with this route.",
            "default": null,
            "type": "integer",
            "format": "uint8",
            "minimum": 0
          },
          "vlan_id": {
            "nullable": true,
            "description": "The VLAN id associated with this route.",
            "default": null,
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          }
        },
        "required": [
          "destination",
          "nexthop"
        ]
      },
      "Saga": {
        "description": "Sagas\n\nThese are currently only intended for observability by developers.  We will eventually want to flesh this out into something more observable for end users.",
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "format": "uuid"
          },
          "state": {
            "$ref": "#/components/schemas/SagaState"
          }
        },
        "required": [
          "id",
          "state"
        ]
      },
      "SagaErrorInfo": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "error": {
                "type": "string",
                "enum": [
                  "action_failed"
                ]
              },
              "source_error": {}
            },
            "required": [
              "error",
              "source_error"
            ]
          },
          {
            "type": "object",
            "properties": {
              "error": {
                "type": "string",
                "enum": [
                  "deserialize_failed"
                ]
              },
              "message": {
                "type": "string"
              }
            },
            "required": [
              "error",
              "message"
            ]
          },
          {
            "type": "object",
            "properties": {
              "error": {
                "type": "string",
                "enum": [
                  "injected_error"
                ]
              }
            },
            "required": [
              "error"
            ]
          },
          {
            "type": "object",
            "properties": {
              "error": {
                "type": "string",
                "enum": [
                  "serialize_failed"
                ]
              },
              "message": {
                "type": "string"
              }
            },
            "required": [
              "error",
              "message"
            ]
          },
          {
            "type": "object",
            "properties": {
              "error": {
                "type": "string",
                "enum": [
                  "subsaga_create_failed"
                ]
              },
              "message": {
                "type": "string"
              }
            },
            "required": [
              "error",
              "message"
            ]
          }
        ]
      },
      "SagaResultsPage": {
        "description": "A single page of results",
        "type": "object",
        "properties": {
          "items": {
            "description": "list of items on this page of results",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Saga"
            }
          },
          "next_page": {
            "nullable": true,
            "description": "token used to fetch the next page of results (if any)",
            "type": "string"
          }
        },
        "required": [
          "items"
        ]
      },
      "SagaState": {
        "oneOf": [
          {
            "description": "Saga is currently executing",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "running"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "Saga completed successfully",
            "type": "object",
            "properties": {
              "state": {
                "type": "string",
                "enum": [
                  "succeeded"
                ]
              }
            },
            "required": [
              "state"
            ]
          },
          {
            "description": "One or more saga actions failed and the saga was successfully unwound (i.e., undo actions were executed for any actions that were completed). The saga is no longer running.",
            "type": "object",
            "properties": {
              "error_info": {
                "$ref": "#/components/schemas/SagaErrorInfo"
              },
              "error_node_name": {
                "$ref": "#/components/schemas/NodeName"
              },
              "state": {
                "type": "string",
                "enum": [
                  "failed"
                ]
              }
            },
            "required": [
              "error_info",
              "error_node_name",
              "state"
            ]
          },
          {
            "description": "One or more saga actions failed, *and* one or more undo actions failed during unwinding.  State managed by the saga may now be inconsistent. Support may be required to repair the state.  The saga is no longer running.",
            "type": "object",
            "properties": {
              "error_info": {
                "$ref": "#/components/schemas/SagaErrorInfo"
              },
              "error_node_name": {
                "$ref": "#/components/schemas/NodeName"
              },
              "state": {
                "type": "string",
                "enum": [
                  "stuck"
                ]
              },
              "undo_error_node_name": {
                "$ref": "#/components/schemas/NodeName"
              },
              "undo_source_error": {}
            },
            "required": [
              "error_info",
              "error_node_name",
              "state",
              "undo_error_node_name",
              "undo_source_error"
            ]
          }
        ]
      },
      "ServerId": {
        "description": "A unique ID for a Clickhouse Server",
        "type": "integer",
        "format": "uint64",
        "minimum": 0
      },
      "SledAgentInfo": {
        "description": "Sent by a sled agent to Nexus to inform about resources",
        "type": "object",
        "properties": {
          "baseboard": {
            "description": "Describes the sled's identity",
            "allOf": [
              {
                "$ref": "#/components/schemas/Baseboard"
              }
            ]
          },
          "decommissioned": {
            "description": "Whether the sled-agent has been decommissioned by nexus\n\nThis flag is only set to true by nexus. Setting it on an upsert from sled-agent has no effect.",
            "type": "boolean"
          },
          "generation": {
            "description": "The generation number of this request from sled-agent",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "reservoir_size": {
            "description": "Amount of RAM dedicated to the VMM reservoir\n\nMust be smaller than \"usable_physical_ram\"",
            "allOf": [
              {
                "$ref": "#/components/schemas/ByteCount"
              }
            ]
          },
          "role": {
            "description": "Describes the responsibilities of the sled",
            "allOf": [
              {
                "$ref": "#/components/schemas/SledRole"
              }
            ]
          },
          "sa_address": {
            "description": "The address of the sled agent's API endpoint",
            "type": "string"
          },
          "usable_hardware_threads": {
            "description": "The number of hardware threads which can execute on this sled",
            "type": "integer",
            "format": "uint32",
            "minimum": 0
          },
          "usable_physical_ram": {
            "description": "Amount of RAM which may be used by the Sled's OS",
            "allOf": [
              {
                "$ref": "#/components/schemas/ByteCount"
              }
            ]
          }
        },
        "required": [
          "baseboard",
          "decommissioned",
          "generation",
          "reservoir_size",
          "role",
          "sa_address",
          "usable_hardware_threads",
          "usable_physical_ram"
        ]
      },
      "SledId": {
        "type": "object",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/TypedUuidForSledKind"
          }
        },
        "required": [
          "id"
        ]
      },
      "SledPolicy": {
        "description": "The operator-defined policy of a sled.",
        "oneOf": [
          {
            "description": "The operator has indicated that the sled is in-service.",
            "type": "object",
            "properties": {
              "kind": {
                "type": "string",
                "enum": [
                  "in_service"
                ]
              },
              "provision_policy": {
                "description": "Determines whether new resources can be provisioned onto the sled.",
                "allOf": [
                  {
                    "$ref": "#/components/schemas/SledProvisionPolicy"
                  }
                ]
              }
            },
            "required": [
              "kind",
              "provision_policy"
            ]
          },
          {
            "description": "The operator has indicated that the sled has been permanently removed from service.\n\nThis is a terminal state: once a particular sled ID is expunged, it will never return to service. (The actual hardware may be reused, but it will be treated as a brand-new sled.)\n\nAn expunged sled is always non-provisionable.",
            "type": "object",
            "properties": {
              "kind": {
                "type": "string",
                "enum": [
                  "expunged"
                ]
              }
            },
            "required": [
              "kind"
            ]
          }
        ]
      },
      "SledProvisionPolicy": {
        "description": "The operator-defined provision policy of a sled.\n\nThis controls whether new resources are going to be provisioned on this sled.",
        "oneOf": [
          {
            "description": "New resources will be provisioned on this sled.",
            "type": "string",
            "enum": [
              "provisionable"
            ]
          },
          {
            "description": "New resources will not be provisioned on this sled. However, if the sled is currently in service, existing resources will continue to be on this sled unless manually migrated off.",
            "type": "string",
            "enum": [
              "non_provisionable"
            ]
          }
        ]
      },
      "SledRole": {
        "description": "Describes the role of the sled within the rack.\n\nNote that this may change if the sled is physically moved within the rack.",
        "oneOf": [
          {
            "description": "The sled is a general compute sled.",
            "type": "string",
            "enum": [
              "gimlet"
            ]
          },
          {
            "description": "The sled is attached to the network switch, and has additional responsibilities.",
            "type": "string",
            "enum": [
              "scrimlet"
            ]
          }
        ]
      },
      "SledSelector": {
        "type": "object",
        "properties": {
          "sled": {
            "description": "ID of the sled",
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "sled"
        ]
      },
      "SledState": {
        "description": "The current state of the sled, as determined by Nexus.",
        "oneOf": [
          {
            "description": "The sled is currently active, and has resources allocated on it.",
            "type": "string",
            "enum": [
              "active"
            ]
          },
          {
            "description": "The sled has been permanently removed from service.\n\nThis is a terminal state: once a particular sled ID is decommissioned, it will never return to service. (The actual hardware may be reused, but it will be treated as a brand-new sled.)",
            "type": "string",
            "enum": [
              "decommissioned"
            ]
          }
        ]
      },
      "SledVmmState": {
        "description": "A wrapper type containing a sled's total knowledge of the state of a VMM.",
        "type": "object",
        "properties": {
          "migration_in": {
            "nullable": true,
            "description": "The current state of any inbound migration to this VMM.",
            "allOf": [
              {
                "$ref": "#/components/schemas/MigrationRuntimeState"
              }
            ]
          },
          "migration_out": {
            "nullable": true,
            "description": "The state of any outbound migration from this VMM.",
            "allOf": [
              {
                "$ref": "#/components/schemas/MigrationRuntimeState"
              }
            ]
          },
          "vmm_state": {
            "description": "The most recent state of the sled's VMM process.",
            "allOf": [
              {
                "$ref": "#/components/schemas/VmmRuntimeState"
              }
            ]
          }
        },
        "required": [
          "vmm_state"
        ]
      },
      "SourceNatConfig": {
        "description": "An IP address and port range used for source NAT, i.e., making outbound network connections from guests or services.",
        "type": "object",
        "properties": {
          "first_port": {
            "description": "The first port used for source NAT, inclusive.",
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "ip": {
            "description": "The external address provided to the instance or service.",
            "type": "string",
            "format": "ip"
          },
          "last_port": {
            "description": "The last port used for source NAT, also inclusive.",
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          }
        },
        "required": [
          "first_port",
          "ip",
          "last_port"
        ]
      },
      "Srv": {
        "type": "object",
        "properties": {
          "port": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "prio": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "target": {
            "type": "string"
          },
          "weight": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          }
        },
        "required": [
          "port",
          "prio",
          "target",
          "weight"
        ]
      },
      "SwitchLocation": {
        "description": "Identifies switch physical location",
        "oneOf": [
          {
            "description": "Switch in upper slot",
            "type": "string",
            "enum": [
              "switch0"
            ]
          },
          {
            "description": "Switch in lower slot",
            "type": "string",
            "enum": [
              "switch1"
            ]
          }
        ]
      },
      "SwitchPutRequest": {
        "type": "object",
        "properties": {
          "baseboard": {
            "$ref": "#/components/schemas/Baseboard"
          },
          "rack_id": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "baseboard",
          "rack_id"
        ]
      },
      "SwitchPutResponse": {
        "type": "object"
      },
      "TxEqConfig": {
        "description": "Per-port tx-eq overrides.  This can be used to fine-tune the transceiver equalization settings to improve signal integrity.",
        "type": "object",
        "properties": {
          "main": {
            "nullable": true,
            "description": "Main tap",
            "type": "integer",
            "format": "int32"
          },
          "post1": {
            "nullable": true,
            "description": "Post-cursor tap1",
            "type": "integer",
            "format": "int32"
          },
          "post2": {
            "nullable": true,
            "description": "Post-cursor tap2",
            "type": "integer",
            "format": "int32"
          },
          "pre1": {
            "nullable": true,
            "description": "Pre-cursor tap1",
            "type": "integer",
            "format": "int32"
          },
          "pre2": {
            "nullable": true,
            "description": "Pre-cursor tap2",
            "type": "integer",
            "format": "int32"
          }
        }
      },
      "TypedUuidForDatasetKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForDemoSagaKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForDownstairsRegionKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForExternalIpKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForOmicronZoneKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForPhysicalDiskKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForSledKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForUpstairsRepairKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForUpstairsSessionKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForZpoolKind": {
        "type": "string",
        "format": "uuid"
      },
      "UninitializedSled": {
        "description": "A sled that has not been added to an initialized rack yet",
        "type": "object",
        "properties": {
          "baseboard": {
            "$ref": "#/components/schemas/Baseboard"
          },
          "cubby": {
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          },
          "rack_id": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "baseboard",
          "cubby",
          "rack_id"
        ]
      },
      "UninitializedSledId": {
        "description": "The unique hardware ID for a sled",
        "type": "object",
        "properties": {
          "part": {
            "type": "string"
          },
          "serial": {
            "type": "string"
          }
        },
        "required": [
          "part",
          "serial"
        ]
      },
      "UninitializedSledResultsPage": {
        "description": "A single page of results",
        "type": "object",
        "properties": {
          "items": {
            "description": "list of items on this page of results",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/UninitializedSled"
            }
          },
          "next_page": {
            "nullable": true,
            "description": "token used to fetch the next page of results (if any)",
            "type": "string"
          }
        },
        "required": [
          "items"
        ]
      },
      "UplinkAddressConfig": {
        "type": "object",
        "properties": {
          "address": {
            "$ref": "#/components/schemas/IpNet"
          },
          "vlan_id": {
            "nullable": true,
            "description": "The VLAN id (if any) associated with this address.",
            "default": null,
            "type": "integer",
            "format": "uint16",
            "minimum": 0
          }
        },
        "required": [
          "address"
        ]
      },
      "UpstairsRepairType": {
        "type": "string",
        "enum": [
          "live",
          "reconciliation"
        ]
      },
      "UserId": {
        "title": "A username for a local-only user",
        "description": "Usernames must begin with a lower case ASCII letter, be composed exclusively of lowercase ASCII, uppercase ASCII, numbers, and '-', and may not end with a '-'. Usernames cannot be a UUID, but they may contain a UUID. They can be at most 63 characters long.",
        "type": "string",
        "pattern": "^(?![0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$)^[a-z]([a-zA-Z0-9-]*[a-zA-Z0-9]+)?$",
        "minLength": 1,
        "maxLength": 63
      },
      "VmmRuntimeState": {
        "description": "The dynamic runtime properties of an individual VMM process.",
        "type": "object",
        "properties": {
          "gen": {
            "description": "The generation number for this VMM's state.",
            "allOf": [
              {
                "$ref": "#/components/schemas/Generation"
              }
            ]
          },
          "state": {
            "description": "The last state reported by this VMM.",
            "allOf": [
              {
                "$ref": "#/components/schemas/VmmState"
              }
            ]
          },
          "time_updated": {
            "description": "Timestamp for the VMM's state.",
            "type": "string",
            "format": "date-time"
          }
        },
        "required": [
          "gen",
          "state",
          "time_updated"
        ]
      },
      "VmmState": {
        "description": "One of the states that a VMM can be in.",
        "oneOf": [
          {
            "description": "The VMM is initializing and has not started running guest CPUs yet.",
            "type": "string",
            "enum": [
              "starting"
            ]
          },
          {
            "description": "The VMM has finished initializing and may be running guest CPUs.",
            "type": "string",
            "enum": [
              "running"
            ]
          },
          {
            "description": "The VMM is shutting down.",
            "type": "string",
            "enum": [
              "stopping"
            ]
          },
          {
            "description": "The VMM's guest has stopped, and the guest will not run again, but the VMM process may not have released all of its resources yet.",
            "type": "string",
            "enum": [
              "stopped"
            ]
          },
          {
            "description": "The VMM is being restarted or its guest OS is rebooting.",
            "type": "string",
            "enum": [
              "rebooting"
            ]
          },
          {
            "description": "The VMM is part of a live migration.",
            "type": "string",
            "enum": [
              "migrating"
            ]
          },
          {
            "description": "The VMM process reported an internal failure.",
            "type": "string",
            "enum": [
              "failed"
            ]
          },
          {
            "description": "The VMM process has been destroyed and its resources have been released.",
            "type": "string",
            "enum": [
              "destroyed"
            ]
          }
        ]
      },
      "Vni": {
        "description": "A Geneve Virtual Network Identifier",
        "type": "integer",
        "format": "uint32",
        "minimum": 0
      },
      "ZpoolName": {
        "title": "The name of a Zpool",
        "description": "Zpool names are of the format ox{i,p}_<UUID>. They are either Internal or External, and should be unique",
        "type": "string",
        "pattern": "^ox[ip]_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
      },
      "ZpoolPutRequest": {
        "description": "Identifies information about a Zpool that should be part of the control plane.",
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "format": "uuid"
          },
          "physical_disk_id": {
            "$ref": "#/components/schemas/TypedUuidForPhysicalDiskKind"
          },
          "sled_id": {
            "type": "string",
            "format": "uuid"
          }
        },
        "required": [
          "id",
          "physical_disk_id",
          "sled_id"
        ]
      },
      "SemverVersion": {
        "type": "string",
        "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$"
      },
      "TypedUuidForDownstairsKind": {
        "type": "string",
        "format": "uuid"
      },
      "TypedUuidForUpstairsKind": {
        "type": "string",
        "format": "uuid"
      },
      "IdSortMode": {
        "description": "Supported set of sort modes for scanning by id only.\n\nCurrently, we only support scanning in ascending order.",
        "oneOf": [
          {
            "description": "sort in increasing order of \"id\"",
            "type": "string",
            "enum": [
              "id_ascending"
            ]
          }
        ]
      },
      "TypedUuidForPropolisKind": {
        "type": "string",
        "format": "uuid"
      }
    },
    "responses": {
      "Error": {
        "description": "Error",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      }
    }
  }
}