From f13fd00ae809a2b760307f10fb50f6eb263d3727 Mon Sep 17 00:00:00 2001 From: nv-dmendoza <117955115+nv-dmendoza@users.noreply.github.com> Date: Sat, 1 Aug 2026 00:36:18 +0000 Subject: [PATCH 01/26] chore: start rc for v2.1.0 Signed-off-by: nv-dmendoza <117955115+nv-dmendoza@users.noreply.github.com> --- CHANGELOG.md | 487 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 487 insertions(+) create mode 100644 CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000..9317e95aa2 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,487 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + + + +## [v2.1.0] - 2026-08-01 + +### Added + +- Added REST endpoints for Machine BMC reset, DPU reprovisioning, and health report override management, proxying authorized Provider Admin requests through the NICo Core gRPC proxy to the machine's owning Site. BMC reset supports an optional ipmitool reset selection; DPU reprovisioning accepts Set, Clear, or Restart modes with an optional firmware update; and health override endpoints support listing, inserting, and removing overrides. See https://nvidia.github.io/infra-controller/ for the updated schema. (#2849) +- Added HostInband as a first-class provisioning network segment type, enabling DPU-less provisioning scenarios. The site explorer now includes HostInband segments in its scan set and correctly tolerates a BMC interface preallocated on a HostInband segment sharing the same machine ID. The admin CLI gained a host-inband-segment mode that creates a flat VPC and HostInband segment through new RPC operations. (#1978) +- Added a `ConfigureCertificate` phase to the switch controller lifecycle, integrating with RMS job execution to automate certificate provisioning on managed switches. (#2330) +- Moved the NICo REST API database from the standalone `postgres.postgres` StatefulSet onto the shared Zalando-managed `nico-pg-cluster`, eliminating the separate REST database instance and consolidating PostgreSQL management. This is a breaking infrastructure change that requires database migration during upgrade. (#3081) +- Added support for multiple DPUDeployments in DPF, allowing BlueField-4 DPUs to be provisioned alongside BlueField-3 using separate deployment configurations with DPUs automatically routed based on hardware part number. The DPF TOML configuration structure has been updated to use a `deployments` section; existing BF3 configuration is now nested under this section and remains the default when not explicitly specified. Attempting to register a BF4 DPU when no BF4 deployment is configured fails with a clear error. (#3084) +- Added an OperationRunDispatcher to the Flow service that periodically locks, reconciles, and dispatches pending operation runs while enforcing conflict, safety, and phase policies. The dispatcher is integrated into the Flow service lifecycle for coordinated startup and shutdown. (#3093) +- Added `HostHardwareType::HpeProliantDl380aGen11` to the BMC mock, representing the first HPE hardware type supported in the test infrastructure. The mock is modeled from a real DL380a Gen11 with a BlueField-3 SuperNIC and includes authentic identity values, expected lockdown state, and iLO serial-console BIOS attributes captured from physical hardware. (#3133) +- Added NVUE REST collection for switch reboot reason and leakage sensor data. Reboot reason events are emitted as structured `reboot_reason_info` metadata, while leakage sensor readings are translated into StateSet metrics and switch health reports with `ok`, leak alert, or sensor-failure classifications. Per-path configuration flags allow independent enablement of each collection type. (#3125) +- Added a NMX-C `Subscribe` streaming collector to carbide-health that connects to eligible primary switch-host NMX-C gRPC endpoints, validates the subscribe acknowledgement, and emits received notifications as structured log events through tracing, log-file, and OTLP sinks. mTLS security support for switch host collectors is tracked separately and will be addressed in a follow-on change. (#3121) +- Added gRPC operations for querying operation runs: `GetOperationRun`, `ListOperationRuns`, and `ListOperationRunTargets`. A shared statistics collector is included to support aggregation across operation run queries. (#3146) +- Added a `bmc_ip_allocation` field to `ExpectedMachine` that gives operators explicit control over BMC IP address assignment and retention. The default `auto` behavior retains an auto-allocated address as a static reservation so it survives DHCP lease expiry, eliminating a recurring source of failures such as DPF re-registration and state machine placement issues. Additional modes include `fixed` (requires a pre-configured address), `retained` (always pins an auto-allocated address), and `dynamic` (opt-out that preserves lease-based behavior). (#2955) +- Added OpenTelemetry trace ID tagging to site-agent gRPC client response log entries, enabling operators to correlate individual RPC log lines back to the workflow that issued the call. Previously, response logs included only method, status code, and duration with no workflow context. (#3005) +- Added a VPC creation command to the admin CLI, allowing operators to define a flat VPC without modifying the configuration file and redeploying. This is particularly useful for bootstrapping environments in DPU-less deployments. (#3145) +- Added a network segment creation command to the admin CLI, allowing operators to define a host-inband network segment without modifying the configuration file and redeploying. This is particularly useful for bootstrapping DPU-less environments. (#3143) +- Added DpuFlavor configuration support for BlueField-4 DPUs in the DPF integration, extending flavor definitions to cover BF4 hardware variants alongside the existing BF3 support. (#3195) +- Updated the BMC mock to route incoming Redfish requests using the HTTP `Host` header as a fallback when the primary routing mechanism is unavailable. This improves compatibility with clients that identify the target BMC via the Host header. (#3190) +- Added the data model and protobuf foundation for an iPXE template-based operating system variant to the REST API, introducing per-OS scope options (Local, Global, Limited) alongside the existing Image and raw iPXE variants. Schema support for OS definitions to stay in sync with on-site NICo Core is included; no handler, workflow, or route wiring is activated in this change — API and SDK layers follow in subsequent changes. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3160) +- Added BlueField-4 PF0 MAC address discovery via the `/redfish/v1/Chassis/BlueField_0/NetworkAdapters/BlueField_NIC_0/NetworkDeviceFunctions/0` Redfish path. The host-side base MAC is derived by applying a fixed offset of 0x10 to the value at that path, replacing the legacy discovery paths that are not valid on BF4 hardware. (#3115) +- Extended the `discover_dhcp` API to support DHCPv6, routing discovery through explicit `address_family` and `message_kind` fields. DHCPv6 stateful requests and the DHCPv6 INFORMATION-REQUEST/SLAAC observation path are now supported; existing IPv4 callers that omit both fields retain their current behavior unchanged. DPA DHCP handling remains IPv4-only. (#2988) +- Introduced `carbide-instrument`, a unified observability framework that lets NICo components declare a significant event once and emit both a structured log line and a Prometheus metric together from a single call. Metric names are validated at compile time (enforcing the `carbide_` prefix, `_total` counters, and unit-suffixed histograms), and high-cardinality values are confined to log-only context fields to keep metric series counts bounded. (#3192) +- Added a background process that periodically republishes the status of all managed hosts to the message bus. The republish interval and the set of data included are configurable, allowing operators to tune reporting frequency and payload to their environment. (#2359) +- Replaced the hand-written `/admin` configuration page with a generated configuration catalog derived from the live `CarbideConfig` and its schema. The new page covers all configuration options (previously only ~35 of ~230 were shown), displays their effective values, and indicates each value's provenance — whether it came from a config file, site overlay, environment variable, or compiled default. The catalog stays automatically in sync as new options are added. (#3223) +- Added a `carbide_log_events_total` Prometheus counter that tracks every log line emitted by a NICo binary, labeled by severity level and the component that produced it. The metric is incremented by a subscriber in the tracing stack with no changes required to existing logging call sites, making log volume and per-component error rates directly observable in Prometheus. (#3244) +- Added automatic rate, error, and latency instrumentation for every outbound gRPC call made by any NICo binary. The generated client code now wraps each method in a `carbide_instrument` helper that records a value into the `carbide_external_call_duration_milliseconds` histogram, labeled by the target service, the method name, and outcome, with no changes required to calling code. (#3245) +- Added Prometheus metrics to `carbide-dns` covering query count by type (`carbide_dns_queries_total{qtype}`), response count by result code (`carbide_dns_responses_total{rcode}`), and a request latency histogram. Existing per-request log lines are unchanged; the metrics are purely additive. (#3268) +- Added a Prometheus `/metrics` endpoint and three counters to the DPU DHCP server: `carbide_dhcp_requests_total{message_type}`, `carbide_dhcp_dropped_requests_total{reason}`, and `carbide_dhcp_leases_granted_total`. The endpoint is enabled via an optional `--metrics-listen-addr` flag served on port 10080; both the DPF DaemonSet chart and the legacy supervisor template pass this flag. Deployments without the flag continue to work unchanged. (#3286) +- Added Prometheus counters for three security-relevant events: RBAC denials (`carbide_auth_denied_total{principal_class, authorizer}`), client certificate rejections (`carbide_authn_client_cert_rejected_total{reason}`), and BMC password rotations (`carbide_bmc_credential_rotation_total{outcome}`). Each counter is paired with the existing log line for the event, making denial spikes and credential rotation failures directly alertable. (#3266) +- Improved MNNVL capability detection to cover GB300 and VeraRubin systems. Detection now checks GPU platform info and known GPU name markers first; if none match, it falls back to scanning `dmi_data.product_name` for MNNVL markers, handling cases such as VR systems where the GPU name does not carry the platform identifier but the DMI product name does. (#3300) +- Added GB300 platform support to the BMC mock and expanded integration test coverage to all three supported GB300 variants. (#3295) +- Completed DHCP drop and reply metric coverage in the Kea hook. Added `carbide_dhcp_replies_sent_total{message_type}` to count every reply Kea sends, and extended `carbide_dhcp_dropped_requests_total{reason}` to capture eight previously uncounted hard-drop and allocation-refusal paths. Existing dashboards using the `dropped_requests` metric are unaffected: the exposed name, label key, and all pre-existing reason strings are unchanged. (#3320) +- Implemented manual control gRPCs for workflow operation runs: Pause, Resume, AdvancePhase, and Cancel. Operators can now intervene in a running operation without waiting for it to complete or fail naturally. (#3308) +- Expanded the new hardware support guide with documentation covering the upstream `libredfish` and `nv-redfish` contribution flow, live-BMC testing procedures using `bmc-explorer-cli` and `nico-admin-cli`, optional BMC mock coverage, and HCL, dependency update, and PR evidence requirements. (#3282) +- Added Prometheus metrics for two previously unobservable machine-stalling conditions: state-handler wake-up failures are now counted via `carbide_state_handler_wakeup_failures_total{trigger}` with a label identifying which trigger path failed, and firmware-upgrade retry exhaustion is tracked by a dedicated counter. The state-controller error count, which was previously only written to logs, is now also exported as a metric. (#3272) +- The `[site_explorer] create_switches` configuration option now defaults to `true`, aligning with the existing `create_machines` default. When switches are discovered during site exploration but skipped because `create_switches` is `false`, an informational log message is now emitted. Operators who previously relied on the `false` default to suppress switch creation must now explicitly set `create_switches = false`. (#3280) +- Added RED (Rate, Errors, Duration) instrumentation to all 31 NSM, PSM, and RMS call sites in the component manager. The new `carbide_external_call_duration_milliseconds{backend, operation, outcome}` metric provides per-backend, per-operation request rate, error rate, and latency across all three external backends. (#3333) +- Added a `carbide_pxe_boot_outcomes_total{endpoint, reason}` counter that tracks every PXE boot request outcome, including failure cases previously hidden behind HTTP 200 responses. The `/metrics` endpoint now serves both the existing `http_*` family and the new outcome metrics in a single scrape, making every boot-path failure reason directly observable. (#3331) +- Added two observability signals for client certificate lifecycle management: `carbide_certs_renewals_total{outcome}` counts every renewal attempt from the shared `ClientCertRenewer` used by the DPU agent and OTel agent, and `client_cert_expiry_time_seconds` exposes how close each agent's certificate is to expiring. Successful renewals, previously silent, are now logged at INFO level alongside the existing ERROR logging for failures. (#3326) +- Fixed structural gaps in the health data plane that prevented `_component_failures_total{component_kind="sink"}` from ever incrementing when sinks failed. Added `carbide_health_otlp_export_*` counters for OTLP drain batch outcomes and instrumented health-report submission failures, making all three egress edges observable. Fanout behavior is preserved: one failing sink logs, counts, and the remaining sinks continue to receive events. (#3336) +- Added support for per-DPUDeployment mandatory service overrides in the DPF configuration. Each deployment entry (such as `bf3` or `bf4_generic`) can now define its own `services` block to pin specific service versions or images; when omitted, the top-level `[dpf.services]` set is inherited with no behavior change for existing configurations. (#3203) +- Updated the DPF integration to the VR0.6 nightly build (`84bc3187`), enabling BF4 hardware support within NICo. The updated DPF version preserves the 26.4 API surface used by NICo, with the exception of `DpfOperatorConfig` which is not managed by NICo. (#3302) +- Added a Firmware tab to the admin web UI that displays desired firmware configurations for managed hosts. The new page gives operators direct visibility into firmware targets without requiring CLI or API access. (#3250) +- Extended the BMC mock to persist NTP server list and enabled state across `PATCH`/`GET` requests on the `ManagerNetworkProtocol` endpoint, enabling NTP configuration testing in simulation environments. (#3354) +- Added an `includeGpuStats` query parameter to `GET /v2/org/{org}/nico/site` that returns per-site GPU totals and machine counts grouped by GPU model when set to `true` by a Provider Admin. The `gpuStats` field is additive and returns `null` when the parameter is omitted, with aggregation performed in the database via a shared helper now also used by the existing per-site GPU stats endpoint. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3140) +- Added BF4-class DPU provisioning via a `BlueFieldSoftware` custom resource (OS ISO and PLDM firmware bundle), alongside the existing BFB-based BF3 provisioning path. The `bfb_url` field is now optional; a deployment uses either `bfb_url` (BF3) or `bluefield_software` (BF4), and NICo creates a separate `DPUDeployment` per PSID for BF4 hardware. (#3361) +- Added a dedicated `[tls.switch]` configuration profile for mTLS connections to switch collectors (NVUE REST, NVUE gNMI, NMX-T, and NMX-C). The profile supports a switch CA bundle, client certificate, client key, and an optional TLS server name for DNS-SAN verification when connecting to discovered switch IPs. Certificate material is validated at startup and on client construction, with clear errors for missing, malformed, mismatched, or expired material; NVUE REST and NMX-T reload certificate files automatically on rotation via a shared HTTP client provider. (#3297) +- Added Prometheus metrics for the MQTT client library, exporting connection state and per-client traffic statistics that were previously tracked internally but never exposed. New gauges cover pending queue size (`carbide_mqtt_queue_pending_messages`, `carbide_mqtt_queue_pending_bytes`) and connection state (`carbide_mqtt_connected`), while counters track processed, failed, and dropped messages, publish outcomes, and event-loop errors, all labeled by compile-time client name (`dsx_event_bus`, `dpa`, `dsx_exchange_consumer`). (#3382) +- Added a machine status HTTP endpoint and lightweight HTML UI to the combined BMC mock listener, exposing current host and DPU state, API state, power state, IP addresses, and Redfish port mappings. This is an internal testing and development tool; existing combined router behavior is preserved. (#3390) +- Added Prometheus counters for firmware update outcomes across all three update targets: host BIOS/BMC, DPU NICs, and SuperNICs. The `carbide_firmware_updates_total{target, phase}` counter tracks update starts and completions per target, and a companion counter tracks the silent "wrong version after attempted update" failure case that previously produced only a log warning. Each instrumented event replaces its existing log line at the same severity level. (#3319) +- Added Prometheus counters for machine validation and measured-boot verification outcomes. The `carbide_machine_validation_outcomes_total{outcome, cause}` counter tracks every validation run that completes as passed or failed, with cause labels drawn from the system's health-alert IDs so the counter label and the alert definition can never drift. Attestation quote failures and stale-timeout storms are now distinguishable from genuine test failures in dashboards and alerting. (#3388) +- The `[site_explorer] create_power_shelves` and `explore_power_shelves_from_static_ip` configuration options now default to `true`, matching the `create_machines` and `create_switches` defaults. Explored power shelves that match an `expected_power_shelves` record are now ingested automatically without additional configuration; the expected-hardware records remain the per-device gate, so only declared hardware is ingested. (#3276) +- The `nico-admin-cli expected-machine patch` command now accepts a `--host_nics` flag that takes a JSON array of `ExpectedHostNic` entries and fully replaces the machine's existing host NIC list. Omitting the flag preserves the existing list; passing `--host_nics '[]'` clears it. Also fixed a pre-existing bug where patching without `--sku-id` silently cleared the machine's stored SKU. (#3360) +- Added a `carbide_bmc_proxy_upstream_request_duration_milliseconds{method, status}` histogram that times each request the BMC proxy forwards to the upstream BMC, from dispatch to response headers received. The `status` label classifies upstream responses by HTTP class (`http2xx` through `http5xx`) with transport failures recorded as `error`, making upstream latency and outcome rates directly observable. (#3406) +- Added a `carbide_firmware_download_duration_seconds{outcome}` histogram that times every firmware artifact download attempt with per-cause outcome labeling: `fetch` (no response), `status` (non-2xx), `transfer` (mid-stream break), `checksum` (SHA-256 mismatch), and `io` (staging or rename failure). Each download attempt now emits a single structured log line at the appropriate severity level, replacing the previous pattern that could emit separate completion and error lines for the same failed attempt. (#3407) +- Added three operator-configurable database connection pool settings to the API server configuration: `database_pool_acquire_timeout` (default 30 s), `database_pool_idle_timeout` (default 10 min), and `database_pool_max_lifetime` (default 30 min). All defaults match sqlx's built-in values so existing deployments see no behavioral change; the settings now appear in the configuration reference and can be tuned per site. (#3411) +- Added a `boot-interface` command family to the CLI with three subcommands: `show` (the four-store boot-interface view, relocated from `machine boot-interfaces` which remains as a hidden alias), `candidates` (lists every NIC eligible for boot with the automatic selection marked), and `set` (assigns the primary boot interface by UUID or MAC address). Operators can now inspect and override boot interface selection from a single unified command group. (#3341) +- Added stable idempotency keys to operation-run task submission so that retries after service restarts or transient failures resume the existing task rather than creating duplicate entries or triggering spurious rack-conflict rejections. Idempotent lookup and resume are serialized with an advisory lock, and rack-level conflict admission uses a separate rack advisory lock so concurrent submissions cannot both pass conflict checks simultaneously. (#3372) +- Added rack-aware simulation support to machine-a-tron, enabling integration tests that exercise rack-level topology and lifecycle scenarios. This extends the simulation environment to model rack constraints and verify rack lifecycle behavior end-to-end. (#3207) +- Added a REST API endpoint for managing UEFI credentials, allowing operators to configure UEFI authentication material for managed machines. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3241) +- The OTLP sink now accepts a required `targets` list, replacing the previous single-endpoint configuration; each target carries its own name, endpoint, batching settings, and diagnostic inclusion option. Logs and metrics are forwarded to every configured target using independent queues and drain loops so a slow or unavailable target does not block delivery to others. Existing single-endpoint OTLP configurations must be migrated to the new `targets` list format. (#3415) +- Added Prometheus metrics for the longest-running hardware operations executed by the preingestion manager: BFB copy duration is tracked via `carbide_preingestion_bfb_copy_duration_seconds{outcome}` with `ok`, `error`, and `timeout` outcomes, and firmware upload, upgrade, power, and reset sequences each record their own counters and durations. This gives operators visibility into preingestion performance and failure rates that were previously unobservable. (#3386) +- Added a `carbide_managed_loop_iterations_total{manager, outcome}` heartbeat counter to every long-lived manager loop, including the machine update manager, machine validation, the managed-host-state republisher, and health discovery. Health discovery now retries on failure instead of terminating the task on the first error, improving service resilience. (#3400) +- Added per-operation instrumentation for all Redfish and IPMI hardware interactions. Every Redfish call now records request count, outcome, and latency via `carbide_external_call_duration_milliseconds{backend="redfish", operation, outcome}` across all 104 trait methods with no call-site changes required, and a new `unsupported` outcome label covers vendor responses that indicate an unsupported operation. IPMI power-reset commands are now counted per operation as well. (#3408) +- Added TLS and mutual TLS (mTLS) support to each OTLP sink target, allowing operators to configure CA bundles, client certificates and keys, and TLS server name overrides on a per-target basis. Certificate material is validated at startup and periodically reloaded; if rotated material is invalid or a replacement connection fails, the existing channel remains active until a healthy replacement is established. HTTPS targets without explicit TLS configuration use the host's installed CA certificates for server verification. (#3478) +- Added a `ClusterEndpointSource` that ingests BMC endpoint inventory from either a local JSON file or a Cluster Manager JSON RPC API, enabling hardware health monitoring for fleets managed by an external cluster manager. The source is disabled by default and enabled via the `[endpoint_sources.cluster]` configuration section. (#3359) +- Added an `exclude_services` configuration option to the `collectors.logs.periodic` block, allowing operators to filter out specific Redfish LogServices by substring match on their `@odata.id` before any log entries are fetched. This prevents the BMC web server's HTTP access log (bmcweb Journal) from creating a self-reinforcing noise loop where each Redfish poll generates log entries that are themselves collected on the next poll. (#3349) +- Added backend-neutral APIs and RMS integration to the component manager for asynchronous NVOS password rotation, covering capability checks, job submission, and polling for completion. The implementation tracks pending, completed, failed, unknown, and missing job states and correctly handles cases where a submission may have succeeded but no response was returned, preventing unsafe retries with a potentially stale credential. NVOS rotation is disabled by default and requires explicit configuration to enable. (#3409) +- Added two capabilities to the shared `metrics-endpoint` crate: alternate-prefix mirroring, which exposes every metric simultaneously under a second prefix to support zero-downtime metric renames without breaking existing scrapers or dashboards; and external cancellation via a `CancellationToken` for graceful shutdown of the `/metrics` listener. All binaries now share a single implementation for Prometheus metrics serving. (#3474) +- Added the synchronization layer for Templated iPXE Operating System support, including site-agent inventory collectors that discover Operating Systems and iPXE templates on-site and cloud-side reconcile workflows that keep definitions consistent between NICo Core and NICo REST. Operating Systems whose iPXE template is not yet available in the cloud inventory are skipped during reconcile until the template is present. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3232) +- Added full NICo Core and REST stack support to the DevSpace local development environment, including Core, REST API workers, site manager, site agent, MCP, and machine-a-tron alongside supporting services (Postgres, Vault, cert-manager, Temporal, Keycloak). The bootstrap script works against any Kubernetes distribution without requiring a specific provider, with automatic image loading optimized for `kind-*` contexts. (#3304) +- Added periodic out-of-band GPU count validation to the hardware health service, checking the number of GPUs visible to the BMC against the expected SKU count. This complements existing in-band SKU validation and allows a GPU that drops off the BMC to be detected without waiting for the next in-band lifecycle event. (#3368) +- Added DHCPv6 support to the Kea hook path by decoding DHCPv6 client identity and relay metadata in Rust and routing IPv6 discoveries through the existing DHCP API and cache flow. The implementation includes Kea `pkt6_receive`, `lease6_select`, `pkt6_send`, and `lease6_expire` hook wiring, DHCPv6 option rendering, address-family-aware cache keys, and an example DHCPv6 hook configuration. (#3435) +- Added Prometheus RED metrics for the KMS provider's three outbound Vault Transit operations: encrypt, decrypt, and generate-and-wrap DEK. Each operation now records `carbide_external_call_duration_milliseconds{backend="vault_transit", operation, outcome}` and emits a warning on failure, making Transit call latency and error rates observable without exposing DEK plaintext or key IDs in any label or log line. (#3536) +- Added Prometheus RED metrics to the NVUE REST client. All public methods now record `carbide_external_call_duration_milliseconds{backend="nvue", operation, outcome}` and emit a warning on failure; non-success HTTP status codes are counted as errors, not only transport-level failures. (#3537) +- Added an optional `/metrics` endpoint to the scout on-host control plane. When `--metrics-listen-addr` is configured, scout registers the standard log-events counter and exposes `carbide_scout_actions_total{action, outcome}` and `carbide_scout_stream_connections_total{outcome}` to track control-loop and stream-lifecycle outcomes. The endpoint is opt-in; scout operates as a pure client without the flag. (#3539) +- Added optional IPMI and Serial over LAN (SOL) simulation to the machine-a-tron BMC mock. This establishes the simulator lifecycle and integration foundation for IPMI-capable BMC workflows, enabling local environments to represent an IPMI-capable BMC as a single coherent mock without separately managed external simulator infrastructure. (#3542) +- Added two observability signals to the DSX exchange consumer to make backpressure visible before drops occur. `carbide_dsx_exchange_consumer_queue_pending_messages` is a gauge of current channel occupancy, and `carbide_dsx_exchange_consumer_message_age_seconds` is a histogram of each value message's age at handling time derived from the BMS-supplied event timestamp. (#3573) +- Populated the Lenovo GB300 BMC mock with a representative hardware discovery response, including CPU topology, NVMe and block storage, DMI platform information, GB300 GPUs, memory, TPM, and CX-8, embedded Intel, and BlueField network interfaces. CX-8 PCI paths, slots, and predictable interface names are generated from compact PCI domain/function descriptors following the existing GB200 pattern. (#3590) +- Added `carbide_dpu_agent_report_total{report_loop, outcome}` to count each DPU agent report-loop iteration by loop type and outcome. The counter covers the entire iteration including pre-RPC failures such as container lookups, instance-metadata conversion, and initial FMDS connection, providing an alert signal for DPUs going silently stale. (#3577) +- Added outcome counters to FMDS's two server-side entry points. `carbide_fmds_config_updates_total{outcome}` counts each `update_config` ingest call, and `carbide_fmds_phone_home_total{outcome}` counts phone-home attempts across success, rate-limited, instance-not-found, and error outcomes, providing alert signals for spikes in rejected config pushes or rate-limited devices. (#3572) +- Added state-controller routing for power shelf power control operations. When `power_shelf_use_state_controller` is enabled and bypass is not requested, power-on and power-off actions now persist a maintenance request and return per-shelf results immediately, with the power shelf state controller executing the actual BMC or RMS power control asynchronously from the `Maintenance` state. (#3609) +- Added an "All" pagination option (`limit=0`) to all list views in the NICo web UI, allowing an entire result set to be rendered on a single page for full-page browser search. Also added a per-table client-side search bar that filters visible rows by keyword without requiring a round trip to the server. (#3493) +- Added a per-machine BMC fault injection control API to machine-a-tron, exposing endpoints to list, create, and delete response-injection rules on a simulated machine's BMC. This enables targeted fault simulation for individual machines in local and CI environments without affecting other simulated hardware. (#3586) +- Surfaced previously silent failures across multiple subsystems by adding logging and, where warranted, metrics. Added `carbide_dsx_exchange_consumer_health_report_persist_failures_total` to count DSX health-report persist failures, and converted previously swallowed errors in transaction rollbacks, DHCP TLS-material reads, and other fallback paths into explicit warnings. (#3469) +- Added RED metrics and an audit counter to the GPU and DPU attestation subsystem (nras). Attestation calls and the required JWKS fetch now record `carbide_external_call_duration_milliseconds{backend="nras", operation, outcome}`, and `carbide_attestation_total{device_type, outcome}` provides a per-device-type audit trail with INFO on success and WARN on verifier failure. (#3543) +- Added stable `event_name` identities to all `carbide_instrument::Event` types, separate from the Prometheus `metric_name`. Migrated all 60 production events to reviewed, globally unique event names that appear as structured fields in log output, enabling consistent searchability and future schema documentation without changing existing metric names, labels, or histogram units. (#3581) +- Added restart-safe database persistence for NVOS password rotation state, storing job metadata and status with coverage for retries, quarantine, stale workers, and unknown-outcome reconciliation. Passwords remain in the credential backend; the database records job metadata only. NVOS password rotation is not yet enabled in production. (#3591) +- Added separate `repository` and `tag` Helm values alongside the existing combined `image` string for boot-artifact init containers, the site-agent bootstrap job, and the wait-for-postgres init container. When both forms are present the split fields take precedence; the combined `image` form continues to work for backward compatibility. (#3622) +- Added optional per-claim-mapping audience validation for custom JWT issuers. Operators can now configure a set of accepted audiences on each claim mapping so that a shared issuer serving multiple organizations confines each client token to its intended mapping, rather than allowing any accepted token to match all configured mappings. Existing configurations without per-mapping audiences are unaffected. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3618) +- Added a Helm chart for deploying machine-a-tron as a Kubernetes service. The chart supports multiple named machine groups with configurable hardware profiles (GB300, DGX H100, power shelves, switches), TLS and SPIFFE certificate integration via cert-manager, a Prometheus ServiceMonitor, and optional persistent storage to retain machine state across pod restarts. (#2764) +- Added a `nico-admin-cli redfish reset-bios` command that restores BIOS settings to factory defaults on a BMC identified by its address and credentials, without requiring the machine to be ingested into NICo first. By default the command exits once the BMC accepts the reset request; passing `--reboot` additionally submits a force restart after the BIOS reset succeeds. (#3564) +- Added an `lldp_collector` module to collect LLDP neighbor data on machines, along with a new `lldp-neighbors` CLI command available on the `scout` and `agent` services. The `lldpd` package has also been added to the scout OS image to support this data collection. (#3418) +- Added a design proposal for Machine Validation Reliability and Control, covering durable run items, attempt tracking, heartbeats, stale-run reconciliation, and compatibility with existing run and result APIs. The initial implementation scope defers live logs, active cancellation, and retry workflows to later milestones. (#2070) +- Added compile-time and CI enforcement of the instrumentation house style, requiring the `carbide_` name prefix on all metrics, a single `_total` suffix on counters, standardized `describe` wording, and a corresponding entry in `docs/observability/core_metrics.md` for every counter and histogram. (#3463) +- Added discovery and propagation of the IPMI port advertised by each BMC via Redfish `ManagerNetworkProtocol`, storing it in the exploration report and returning it through the existing BMC metadata API. Consumers such as SSH console can now use the BMC-reported port and fall back to the conventional port 623 only when no port is available. (#3687) +- Added support for automatic VPC prefix selection by VPC ID, allowing callers to specify only a VPC ID when assigning addresses to interfaces rather than an explicit prefix. The implementation resolves the VPC ID to a prefix with available capacity using deterministic static first-fit allocation with canonical lock ordering and savepoint-based retries. IPv4-only, IPv6-only, and dual-stack selection modes are supported, and existing explicit-prefix requests remain fully compatible. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3456) +- Added `--listen-addr` and `--relay-response-port` flags to `forge-dhcp-server`, allowing the UDP listen address and relay response destination port to be configured at startup rather than hardcoded to `0.0.0.0:67`. Both flags default to their previous hardcoded values so existing production deployments are unaffected, while non-privileged environments such as local development can now exercise the full DHCP packet path without elevated privileges. (#3699) +- Added `message = dynamic` support to the instrumentation `Event` derive macro, allowing events to select their log message per instance by implementing the new `DynamicMessage` trait rather than using a single static string. This enables metric-backed events that previously required a separate `tracing::` call per outcome variant to fold all per-variant wording directly into the single `emit()` declaration. (#3705) +- Added a machine maintenance power operation path that mirrors the existing switch and power-shelf state-controller pattern. When `compute_tray_use_state_controller` is enabled, `ComponentPowerControl` for machines queues a `MachineMaintenanceRequest` rather than issuing Redfish commands directly, with the machine state controller dispatching power-on, power-off, and reset actions through the compute_tray backend. (#3683) +- Added routing of NVUE reboot reason metadata through NICo's log sinks, including OTLP export. (#3712) +- Added a configuration-driven certificate vending backend, making PKI issuance a selectable option decoupled from credential storage. The default `SharedVault` backend reuses the existing credential Vault client so current deployments require no changes, while a new `DedicatedVault` option allows operators to direct certificate requests to a separate Vault instance with its own address and PKI mount settings. (#2881) +- Added a `skip_initial_history` flag to the periodic log collector in `forge-hw-health`. When enabled, the collector records the highest existing log entry ID as its starting cursor on first encounter of an unseen `LogService` and discards historical entries without emitting them, so only new events are reported from that point forward, reducing startup noise on clusters with large pre-existing log histories. (#3694) +- Added debug instrumentation to walk and verify that all Astra configs and their corresponding attachments share the same revision. Also fixed the main loop to return an empty Astra config status vector rather than omitting the field when no Astra config is present. (#3722) +- Added IPMI endpoint reporting to machine-a-tron's `/machines/status` API, exposing both the client-facing `reachable_port` advertised through Redfish and the simulator's dynamically allocated `listen_port` for each simulated BMC. This allows external orchestration to create the correct per-BMC port forwarding rules in test environments. (#3724) +- Added explicit, backward-compatible configuration for the bootstrap CA used during DPU provisioning, decoupling it from `nico-pxe`'s outbound API trust bundle. Operators can now supply a BFB-embedded CA bundle or an operator-mounted bundle per site, with the historical unauthenticated CA download preserved as a fallback when no explicit configuration is provided. (#3588) +- Updated documentation to reflect that NMX-M is no longer supported in favor of direct NMX-C management, and added an explicit unsupported error response to the NMX-M credential admin-cli command. (#3601) +- Added a UDP DHCP relay mode to the machine-a-tron simulator, enabling simulated machines to exercise the DHCP server through its packet interface rather than obtaining leases directly via the Carbide API. The new mode performs full DISCOVER/OFFER and REQUEST/ACK exchanges over UDP, including relay-agent information and the vendor class derived from simulated hardware. The existing API mode remains the default for backward compatibility. (#3754) +- The BMC proxy is now deployed as part of the NICo Core Helm chart by default, as it is required for DPS-based power provisioning. The BMC proxy ServiceMonitor and external LoadBalancer Service remain opt-in; the subchart can be disabled only when an external BMC proxy is deployed and wired separately. (#3682) +- Added server-side enrichment of software inventory for DPF-ingested DPUs. Because the NICo agent runs containerized in DPF mode and cannot enumerate DPF-managed services, the API server now reads deployed service versions directly from DPUDeployment and DPUServiceTemplate CRs and persists them in place of the agent-reported data, keeping displayed service versions (HBN, DTS, DHCP, etc.) accurate after upgrades. (#3769) +- Added exponential backoff tracking for BMC credential rotation failures. Failed rotation attempts now record the attempt count, last-attempt timestamp, redacted error message, and a capped backoff window ranging from 60 seconds to 1 hour. Successfully converged rotations clear all stale bookkeeping, keeping the converged and quarantined rotation-status buckets mutually exclusive. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3813) +- Added auto-generated per-pod MAC address pools to machine-a-tron Helm deployments to prevent address collisions across multiple simultaneous pods. Two pool types are allocated: standalone MACs for BMC and DPU interfaces, and contiguous NIC blocks for ConnectX and storage adapters. (#3700) +- Added an isolated local workflow (`make core/tests`) for running Carbide Core integration tests with their required dependencies. The workflow provisions a dedicated PostgreSQL 15.13 container, verifies required host tools and extensions, and supports focused Cargo invocations via the `TEST_ARGS` variable. (#3794) +- Added per-model BMC factory default credential support for DPUs, enabling sites that mix BlueField generations to configure model-specific credentials. During provisioning, NICo probes the Redfish `Product` field to identify the DPU model, then resolves credentials through a fallback chain: model-specific Vault entry → catch-all Vault entry → documented factory defaults (BlueField-4 uses `admin`/`0penBmc`; earlier generations and unknown models use `root`/`0penBmc`). This consolidates with the existing per-vendor credential pattern already used for host hardware. (#3774) +- Added the nico-flow Helm chart to the CI/CD publishing pipeline so it is distributed as a packaged artifact. This resolves ArgoCD v3.4.2 deployment failures caused by updated symlink security checks rejecting out-of-bounds symlinks when the chart was sourced directly from the git repository. (#3869) +- Added a `carbide_metrics_scrape_failures_total` counter labeled by a bounded `ScrapeOutcome` enum to track `/metrics` endpoint scrape failures by error category. The counter is emitted alongside existing log entries at each of the five failure branches, enabling operators to alert on scrape reliability. (#3686) +- Added the `carbide-credential-rotation` crate implementing a crash-safe BMC root password rotation engine. The engine converges a device's BMC password to the staged target via a single guarded synchronous change, with a crash marker to detect mid-rotation failures, change-then-verify recovery to avoid redundant same-value changes, exponential backoff quarantine on repeated failures, and a cached site-wide entry gate. (#3848) +- Added a `carbide_bmc_proxy_authorization_denied_total` counter to track BMC proxy authorization denials by layer (`authorization_layer`) and request method, supplementing the existing log-only diagnostics with a trendable signal. A separate `carbide_bmc_proxy_authorization_errors_total` counter tracks middleware contract violations (missing `AuthContext`), keeping policy rejections distinct from internal errors. (#3877) +- Added a `carbide_machine_identity_token_exchange_failures_total` counter labeled by `failure_stage` to surface machine-identity token exchange failures as an observable metric operators can trend and alert on. The counter covers request send, response read, HTTP rejection, and JSON decoding failure stages; sensitive response content and credentials are explicitly excluded from all metric labels and diagnostic fields. (#3878) +- Added a `carbide_site_explorer_bmc_reset_attempts_total` counter to record every terminal BMC reset attempt labeled by method and outcome status, supplementing the existing `carbide_site_explorer_bmc_reset_count` gauge which retains its latest-run semantics. Timestamp persistence warnings now also increment a dedicated counter, giving operators observable signals for both reset outcomes and file persistence failures. (#3879) +- Added a `carbide_dhcp_timestamp_file_failures_total` counter labeled by `operation` (initialization, write, read) to make DHCP timestamp-file failures observable as a metric. Existing log levels, error messages, and packet-handling control flow are unchanged. (#3880) +- Updated DPF-based provisioning for BlueField-3 to support BFB version 3.4.1. Operators using DPF-based BF3 provisioning must migrate to this firmware baseline. (#3016) +- Changed NVSwitch certificate rotation to trigger based on the certificate's expiry rather than comparing against a certificate file on disk. NICo no longer requires the certificate secret to be mounted in its filesystem, simplifying deployment and reducing filesystem dependencies. (#3975) +- Added a bounded counter for BMC session circuit-breaker transitions, exposing trip and clear events as trendable metrics via a closed `transition` label. BMC MAC address, HTTP status, and count details remain log-only context, separate from the metric. (#3957) +- Added per-device storage cleanup latency and outcome reporting to Scout, emitting a terminal `ScoutStorageDeviceCleanup` event for each NVMe and HDD/SAS device processed. Cleanup duration is recorded via `carbide_scout_storage_device_cleanup_duration_seconds`, labeled by bounded `device_type` and `outcome` values. (#3958) +- Added a bounded counter for WorkLock release and keepalive failures through `carbide_work_lock_failures_total`, distinguishing database, command-dispatch, command-reply, and lock-loss failure paths. Work keys, worker identifiers, and error details remain in correlated log context rather than metric labels. (#3961) +- Added a bounded per-stage counter for DPU remediation executor failures, covering status decoding, local apply/report, response validation, remediation fetch, and Forge client creation failures. Machine and remediation identifiers stay log-only, and delivered script failures and timeouts remain on the existing result-reporting path rather than being counted as executor failures. (#3962) +- Added an opt-in DSX Exchange DevSpace profile that deploys a local NATS MQTT service alongside NICo and wires the event-bus configuration into nico-api. The default DevSpace and Helm paths remain disabled unless the profile is explicitly selected. (#3795) +- Introduced a typed event-rule domain model to Flow as the foundation for defining operator rules that respond to operational events such as hardware coolant leaks. This domain layer enables future event processing features without changing existing configuration or workflows. (#3881) +- Added a counter for Scout stream responses dropped when the API-side outbound channel closes after a request is already handled but before the response is delivered. The counter carries no labels; API endpoint, machine ID, and error detail remain on the log record, and existing reconnect behavior is unchanged. (#3996) +- Added counters for authentication guardrail events, converting existing warnings for missing connection metadata, missing authorization context, and permissive-mode policy overrides into trendable metrics. Labels are restricted to bounded authorizer and principal-class values; request identifiers, client addresses, and access details remain log-only. (#3993) +- Added a counter for Redfish action results lost when a completed BMCResponse cannot be persisted after the initiating request has already returned. Request ID, result index, and database error remain log-only context, and the detached-task and intentional-error-discard behavior is unchanged. (#3995) +- Added a per-operation counter for extension-service credential cleanup failures, covering create, update, and delete paths where best-effort credential deletion can leave orphaned secrets behind. The existing request behavior is unchanged: create and update return the original transaction error, and delete remains successful after its database commit. (#3994) +- Added REST API endpoints for the Templated iPXE Operating System variant and read-only iPXE template resources, including OpenAPI schema definitions and a regenerated Go SDK. Operators can now manage iPXE templates and configure templated-OS provisioning through the standard REST interface. No new database migrations or workflow changes are included; provider-specific behavior is addressed in follow-up work. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3569) +- Added opt-in per-object state progress metrics served from a dedicated listener, exposing which specific state-controller objects are stuck rather than only aggregate fleet counts. The `carbide_object_state_entered_timestamp_seconds` metric enables exact state-age queries and the `carbide_object_state_sla_seconds` metric exposes the resolved SLA for each object's current state; the feature is disabled by default and does not affect the existing `/metrics` endpoint. (#3563) +- Added support for authenticated container image pulls during machine validation, backed by private registries. Registry credentials are stored in the envelope-encrypted secrets journal and can be managed via `nico-admin-cli credential registry set`; Scout retrieves and applies them at pull time without exposing the password to process arguments. (#3867) +- Added Provider Admin REST actions for Site Explorer endpoints, enabling operators to clear exploration errors or re-explore selected endpoint sets through the API. Request validation, OpenAPI definitions, a regenerated Go SDK, and Core authorization for the underlying SiteAgent calls are all included, while preserving the existing Core ownership boundary. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3432) +- Added support for ingesting BlueField-4 DPU BMCs, including automatic product detection via Redfish ServiceRoot, root credential rotation to the site-wide BMC password, and service account password rotation away from the factory default. Credentials are stored per-BMC in Vault following the same pattern used for BlueField-3 devices. (#3858) +- Changed power control to route standalone and rack-scale machines through separate execution paths, dispatching standalone servers directly through NICo-core's Redfish stack and rack-scale servers through the configured RMS backend or the state-controller maintenance flow. This prevents RMS resolution failures for standalone servers in mixed rack deployments. (#3873) +- Added a counter for BMS DSX commands dropped when the worker's receiver has already stopped, emitting `carbide_bms_dsx_commands_dropped_total` with a closed `command_kind` label distinguishing metadata from source-update commands. Existing warning behavior and best-effort API semantics are unchanged. (#4046) +- Added a per-operation counter for BMC session cleanup failures, tracking failed Redfish session revocations and session-row deletions through `carbide_bmc_session_cleanup_failures_total`. BMC MACs, SPIFFE IDs, session IDs, and errors remain log-only context, and existing continue/return behavior after failures is preserved. (#4047) +- Added a counter for IB partition controller invariant failures where a partition in Ready or Deleting state is missing a pkey, emitting `carbide_ib_partition_pkey_missing_total` with a closed `controller_state` label to distinguish the two paths. Existing error messages, state transitions, and log context are unchanged. (#4045) +- Added per-result counters for BMC credential rotation terminal outcomes, emitting `carbide_bmc_credential_rotation_results_total` with a closed `result` label when a device converges, recovers, or enters quarantine. Fast paths for no-work, already-converged, and already-quarantined devices remain silent and uncounted. (#4044) +- Added exact health-alert filtering support on the managed-host page, allowing operators to filter hosts by specific alert conditions. (#3489) +- Added a counter for rack maintenance Vault access token cleanup failures, emitting `carbide_rack_maintenance_access_token_cleanup_failures_total` when the best-effort token deletion step fails after a maintenance workflow completes. Rack ID and deletion error remain log-only, and maintenance completion is unaffected by cleanup failures. (#4082) +- Added Prometheus metrics for machine validation control-plane delivery failures that were previously invisible behind otherwise successful Scout actions. Heartbeat failures now emit `MachineValidationHeartbeatFailed` with bounded `stage` and `reason` labels, while result persistence emits `MachineValidationResultPersistenceFinished` with an `outcome` label. Existing retry, stop, skip, and continue behavior is unchanged; sensitive identifiers and error text remain log-only. (#4084) +- Added the `carbide_firmware_artifact_unavailable_total` metric to count firmware download blockers that occur before a download starts. A bounded `reason` label distinguishes missing artifact URLs from stale cached artifacts that cannot be removed, making both failure modes visible in firmware metrics alongside the existing `DownloadFinished` counters. (#4085) +- Added a development-only DPF operator simulator for machine-a-tron simulation clusters that lack BlueField hardware. The simulator watches `DPUDevice`/`DPUNode` CRs created by NICo and drives `DPU.status.phase` through the full DOCA Platform v26.4.0 sequence to `Ready`, reproducing the node-effect hold and both handshakes that NICo depends on so simulated hosts are no longer stuck at `dpuinit`. (#3807) +- Added the `carbide_rack_maintenance_access_token_cleanup_failures_total` metric via the new `RackForceDeleteAccessTokenCleanupFailed` event for token cleanup failures that occur after a rack force-delete. The existing warning and best-effort continuation behavior are preserved; rack ID and deletion error details remain log-only. (#4115) +- Added the `DpuUefiPasswordSetupSkipped` event to count cases where DPU UEFI password setup is skipped because the Redfish BIOS response cannot support replacing the factory password. A bounded `reason` label distinguishes missing attributes, non-object attributes, and a missing `CurrentUefiPassword` field; no BIOS response or credential material enters telemetry, and existing non-fatal behavior is unchanged. (#4116) +- Added the `DatabaseTransactionRollbackFailed` event to count transaction rollback failures from both explicit cleanup and closure-error cleanup paths. A bounded `trigger` label distinguishes the two cases; the original closure error still takes precedence so transaction return behavior is unchanged, and caller location and rollback error details remain log-only. (#4117) +- Added the `SpdmEvidenceCollectionTaskStateUnexpected` event to count Redfish task states outside the expected set encountered during SPDM evidence collection. Bounded `task_state` and `next_action` labels make the failure path trendable by state type and action taken, while machine, device, task, and retry details remain log-only; existing retry thresholds and error messages are unchanged. (#4118) +- Added SKU schema v5, which validates storage by per-drive capacity range and PCI location rather than drive model and count. Each NVMe entry in the v5 schema carries a `size_mb` and a concrete sysfs/PCI path; validation fails safe with a diff when an expected drive is missing, located at the wrong slot, outside the expected size range, or when an unexpected drive is discovered. (#3717) +- Added end-to-end NVOS switch password rotation support. Site-wide switch targets are stored as immutable versioned secrets, verified before publishing, and then atomically published with live switches enqueued for reconciliation; per-switch credentials are staged and verified before the target is promoted. Passwords remain in the configured credential backend; the database stores versions, attempt metadata, transient RMS job IDs, and redacted failure information. (#3706) +- Machine validation container image references must now include a pinned `@sha256:` component; references without a digest are rejected. Tagged references are accepted as long as a valid 32-byte digest is present. Validation is enforced at both the API handler and the admin CLI via a value parser on the `img_name` field. (#4058) +- Hardware health telemetry now includes an optional BMC-derived primary system UUID emitted as `system_uuid` in Prometheus and `system.uuid` in OTLP resources, providing stable hardware identity for fleet intelligence consumers. Static BMC endpoints can also define user-provided telemetry labels using Prometheus-compatible identifier names. Telemetry collection continues without the UUID label when identity discovery is unavailable. (#4041) +- Setup status reports now include the explicit boot interface target that was checked, preventing a status from a previous target from appearing current after a target change. The target travels as a `Pair(MachineBootInterface)` or `MacOnly(MacAddress)` through periodic exploration, explicit refresh, ad-hoc exploration, credential bootstrap, and each Redfish backend. Reports written before target capture remain valid and are not replaced by the existing CAS mechanism. (#4145) +- Added bounded event families for machine identity boundary failures at two points: decryption failures when reading or re-encrypting signing and delegation secrets, and sign-proxy failures before a response, during response reading or rebuilding, and on upstream 5xx responses. Stable Prometheus counters expose only boundary and failure labels; organization names, URLs, response details, and error text remain log-only. (#4161) +- Topology enrichment and fabric refresh partial failures are now routed through bounded events for switch and Site Explorer RMS paths, unknown RMS certificate states, and partial InfiniBand updates, providing stable Prometheus counters for best-effort degradation. Failed slot and tray writes now roll back before processing continues, allowing valid partial location data to survive; identifiers and error details remain log-only. (#4162) +- Added bounded Prometheus counters for Scout firmware download observation paths and MLX observation operations. A firmware counter tracks script and artifact attempts plus retry and give-up decisions; an MLX counter uses a bounded operation, stage, and failure vocabulary across reconciliation, profile comparison, lockdown status, and device and registry reads. Existing retry behavior and log messages are unchanged; task credentials are redacted from all diagnostics. (#4163) +- Resource pool failures across allocation exhaustion, value rejection, parse and database errors, release failures, startup VPC creation, and DPU ASN allocation are now unified under `carbide_resource_pool_lifecycle_failures_total`. A `failure_policy` label distinguishes required failures from best-effort enrichment so operators can see which pool operations are fatal and which continue; pool names, owners, values, and errors remain log-only. (#4165) +- LLDP, OVS, DHCP, and credential-watcher local runtime recovery paths now emit bounded events with stable Prometheus counters, allowing operators to track restart and setup failure rates without reconstructing them from individual log entries. LLDP and OVS share one bounded event family; emission sites that previously hid `emit()` inside ordinary-looking helpers are now explicit. (#4164) +- Scout firmware mutation paths (profile application, configuration changes, lockdown, firmware flashing, and reconciliation recovery) and MLX mutation paths now emit bounded events using the same event family introduced for observations. Every existing response, retry, control-flow, and log-level decision is preserved; firmware URLs, credential values, and typed lockdown errors are redacted before reaching diagnostics. (#4166) +- The `deny_prefixes` and `deprecated_deny_prefixes` fields now accept IPv6 prefixes in addition to IPv4, using `IpNetwork` in place of `Ipv4Network`. FNN fabric nodes receive configured deny prefixes for both address families, while ETV and flat topologies continue to use IPv4-only deny rules. Overlaps with `site_fabric_prefixes` are validated per address family independently, treating IPv4 and IPv6 as separate spaces. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3882) +- Added an optional `lo-ip-v6` pool that reserves a dedicated IPv6 loopback address per DPU, persisted in `ManagedHostNetworkConfig`. New DPU records allocate from the pool at creation time, and existing records are backfilled during startup or via `AdminGrowResourcePool`. A database trigger protects the reservation from being overwritten by older API pods during mixed-version deployments. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3913) +- Added a `SitePrefix` resource to Core that gives each configured `site_fabric_prefixes` CIDR a stable resource ID and explicit lifecycle with `Configured` and `TenantManaged` authorities. Startup reconciliation keeps row IDs stable across restarts, marks removed CIDRs as `Deleting`, and reactivates them if they return. A transaction advisory lock ensures concurrent Core startup pods converge on a single row per CIDR without disturbing tenant-managed rows. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4031) +- Added coordinated firmware upgrade orchestration across rack power shelves, compute nodes, and switches within a rack maintenance workflow. A new power-shelf reprovisioning state machine, enabled behind an opt-in configuration flag, tracks per-device firmware status and synchronizes component progress, retries, and terminal outcomes. Database migrations, model and RPC wiring, controller configuration, and integration test coverage are included. (#4089) +- When no custom network configuration is set for a machine, the system now automatically generates a default cloud-init network configuration that issues DHCP requests on every discovered network interface. This removes the need to manually define per-interface network config for machines that rely solely on DHCP. (#3708) +- Added DPF provisioning support for BF4 Astra DPUs, including the DPUFlavor, DPUDeployment, and associated service manifests required to provision and manage BF4 Astra hardware under the DPF framework. (#4127) +- Updated `bmc-mock` to forward IPMI chassis reset commands to the mock's power-control callbacks via a per-instance FIFO, enabling consumers such as machine-a-tron to observe and react to IPMI-triggered reboots. (#4138) +- Added optional `role` and `ip_allocation` fields to `ExpectedHostNic`, allowing operators to explicitly classify each expected interface as `Host`, `DpuOs`, or `DpuBmc` and choose between `Dynamic`, `Fixed`, or `Retained` IP allocation. Fixed allocation resolves the address from a configured managed prefix containing `fixed_ip`; Dynamic and Retained allocation uses the DHCP relay or DHCPv6 link segment. An optional `network_segment_type` guard is available for either allocation path. (#3991) +- Added a libvirt-backed mode to `bmc-mock` that maps Redfish power operations to a configured libvirt domain and supports virtual media insertion and ejection, enabling full Redfish workflow simulation for VM-based development and integration testing. (#3912) +- The `nicocli tui` interactive interface now exposes the full set of REST operations available through the generated CLI, closing the gap where some operations were only accessible via non-interactive commands. Existing specialized handlers and interactive resource selection are preserved. (#4206) +- Exposed auto-VPC-prefix selection in the REST API, allowing callers to specify a VPC ID on a network interface to have a prefix automatically selected rather than providing one explicitly. The initial release supports IPv4 VPC prefix selection; both IPv4 and IPv6 are represented in response structures to facilitate future IPv6 support. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3850) +- Introduced a `#[derive(MetricFamily)]` macro that declares a metric's name, kind, component, and description once, eliminating the need for each event type sharing an instrument to repeat the same declaration and reducing metric description drift. (#4263) +- Each DPU's reserved IPv6 loopback address (`loopback_ip_v6`) is now rendered as a `/128` on the FNN loopback interface and permitted through the IPv6 underlay export policy. The address is resolved per-DPU so two DPUs on the same host receive distinct loopbacks; sites without a `lo-ip-v6` pool and ETV topologies remain IPv4-only. (#4256) +- Added REST endpoints under `/v2/org/{org}/nico/task/run` for creating and managing Flow operation runs — phased, policy-gated multi-rack maintenance executions. Operators can create a run with a rack selector, concurrency and safety gate configuration, and an operation to execute; lifecycle actions (pause, resume, advance, cancel) and per-rack target listings are also supported. Each run materializes one execution target per rack that links to existing per-rack Task endpoints for detailed status. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4231) +- Extended `MetricFamily` to support computed labels, where one label's value is derived deterministically from another label, eliminating the boilerplate of per-variant constructors whose sole purpose was enforcing valid label combinations. (#4267) +- Refactored machine-a-tron to use typed device simulators with a shared registry, extending the simulation framework beyond host machines to support switches and power shelves. Machine-centric type and field names were renamed to device-centric equivalents throughout. (#4285) +- Added REST API models and endpoints for credential rotation, providing operators a programmatic interface to rotate credentials for managed infrastructure components. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4272) +- Added support for the RMS v2 `ConfigureScaleUpFabricManagerV2` asynchronous RPC, replacing the multi-step V1 coordination sequence NICo previously managed across switches. The V2 RPC delegates primary switch selection, scale-up fabric reconciliation, NMX-C state verification, and topology readback to RMS as a single desired-state reconciliation job. NICo submits the switch group and desired topology, polls for job completion, then reads and persists the RMS-selected primary and per-switch Fabric Manager status. (#4158) +- Added an event rule management framework that decouples event detection from response handling, replacing the previously hard-coded leak detection behavior. The framework introduces binding and store contracts, an immutable built-in rule registry, manager-driven rule lifecycle, and rack/site scopes with built-in fallback rules. This infrastructure is designed for reuse across thermal alarms, inventory drift, firmware health events, attestation failures, and other event families. (#4278) +- Changed Flow's embedded compute component manager default from `nicolegacy` to `nico`, aligning compute tray dispatch with nvswitch and powershelf component managers. Expected-inventory synchronization (`FLOW_EXPECTED_INVENTORY_SYNC_ENABLED`) now defaults to enabled when unset; operators can opt out by setting the value to `false`, `0`, or `f`. (#4319) +- Added support for custom key-value attributes on rack profiles at both the rack level and the component-role level (compute, switch, power shelf), enabling optional metadata for hardware variant identification and workflow selection beyond predefined profile fields. Attributes follow a defined precedence from rack-level to role-level to built-in fields, and all values must be string-typed. (#4152) +- Added dedicated actors and finite state machines for NVLink switches and power shelves within machine-a-tron, replacing the previously shared machine-oriented actor that coupled their lifecycle to machine-only behavior. A generic mailbox-driven actor with cancellable alarms is also included. Existing machine and DPU actors, configuration, persistence, and Redfish behavior are unchanged. (#4316) +- Added support for optional (`Option`-typed) context fields in the instrumentation framework, allowing event fields that do not apply in a given case to be explicitly absent rather than filled with empty or sentinel values. This eliminates the need to define separate event structs for variants that differ only in which fields are populated. (#4336) +- Added a `RotatingBmc` managed-host state that drives the shared credential-rotation engine across the host BMC and each DPU BMC, converging all devices to the site-wide staged target credential with per-device backoff and quarantine. A site-wide `bmc_rotation_enabled` kill-switch gates passive rotation, and operators can force convergence on individual machines via the `TriggerBmcCredentialRotation` RPC or the `credential force-bmc set/clear` CLI command, addressable by machine ID or BMC MAC. (#4219) +- Added `HostBmc` to the shared expected-interface configuration path, supporting `Dynamic`, `Fixed`, and `Retained` address allocation with an optional `network_segment_type` guard, consistent with the `Host`, `DpuOs`, and `DpuBmc` interface roles. Existing top-level BMC IP and allocation fields are preserved as aliases for backward compatibility, and legacy-only rows continue to use their original storage and wire format. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4283) +- Added a `machine_boot_interfaces` table that persistently records the desired boot NIC MAC address, optional canonical Redfish interface ID, and desired configuration version for each host. This gives the machine controller a restart-safe record of the intended boot interface, preventing the desired target from being lost or confused with discovery defaults during ingestion or after restarts. (#4315) +- Added RFC 2131-style exponential backoff for DHCP retry operations in machine-a-tron, replacing the fixed `run_interval_working` retry interval with a doubling delay ladder from 4 to 64 seconds plus ±1 second jitter. This prevents synchronized retry bursts against the DHCP server or Carbide API during startup or service degradation when many simulated machines retry simultaneously. (#4343) +- Extended site-wide BMC credential rotation to NVLink switches by adding a `RotatingBmc` state to the switch controller. A `Ready` switch whose BMC credentials lag the staged site-wide target now enters `RotatingBmc`, rotates through the shared credential-rotation engine, and returns to `Ready`. The site-wide `bmc_rotation_enabled` gate and the `TriggerBmcCredentialRotation` operator force-converge escape hatch are supported, addressable by machine ID, switch ID, or BMC MAC. (#4344) +- Added REST API endpoints for Provider Admins to create, list, and delete measured-boot trusted-machine and trusted-profile approvals, exposing the existing Core gRPC capability through the OpenAPI-derived command surface. Wildcard deletion and missing-resource error handling in the shared Core implementation were also corrected to match the REST contract. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3464) +- Added per-site and per-account configuration for the `TargetedInstanceCreation` tenant capability, replacing the previous single global flag that applied uniformly across all providers and sites. Authorization is now enforced site-aware end-to-end, preventing over-granting on list endpoints such as machines and sites when only specific sites should have privileged access. See https://nvidia.github.io/infra-controller/ for the updated schema. (#2134) +- Added RMS connectivity settings, the component manager configuration, and NVL72/NVL72_GB300 rack profiles as first-class Helm chart values for the `nico-api` chart, rendered directly into the base `carbide-api-config.toml`. Previously these settings required manual post-deployment editing of the raw site-config TOML on each site. (#4218) +- Added a Kubernetes controller for machine-a-tron that dynamically creates per-BMC Services, providing stable network exposure for mock Redfish endpoints in multi-pod deployments. The controller discovers machine-a-tron pods via a label selector, polls the `/machines/status` API, and reconciles one Service per mock BMC. Machine-a-tron itself remains Kubernetes-agnostic; all Kubernetes logic lives in the separate controller. (#3955) +- Added `ExpectedInterface` and `interfaces` as the canonical Rust, configuration, and admin CLI names for the expected network interface list, which now covers `Host`, `DpuOs`, `DpuBmc`, and `HostBmc` roles. Existing `host_nics` configuration input and `--host_nics` CLI flags continue to work as aliases; protobuf field numbers, wire bytes, and the physical `expected_machines.host_nics` database column are unchanged. (#4390) +- Added versioned policy codecs and data access object conversions for persisting event rules to the database, along with a concurrency-safe in-memory rule and binding store with reader-friendly access patterns. This is the third phase of the event rule management framework, enabling durable rule storage that survives restarts. (#4384) +- Added a database table and helper functions to track BMC MAC addresses that should be suppressed during site exploration and DHCP lease assignment, supporting the decommission workflow where machines being uningested must not be re-discovered or re-leased. This persistence layer is a prerequisite for the site explorer and DHCP suppression logic delivered in subsequent changes. (#3853) +- Added a persisted boot interface verification record and a `BootConfiguring` state to the machine controller, providing a restart-safe and race-safe path for applying a desired boot interface change on a `Ready` host. The controller captures the exact desired target, performs Redfish BIOS and boot-order configuration through the shared HostInit path, restores and verifies lockdown, then atomically updates the verified version only after confirming the configuration via Redfish readback. (#4389) +- Added REST API endpoints enabling Provider Admins to create, partially update, and delete SKUs for a selected site. Mutations are executed through Temporal and the Site Agent to the target site's NICo Core service, and PATCH requests preserve fields omitted from the request body. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3633) +- Extended site-wide BMC credential rotation to power shelves by adding a `RotatingBmc` state to the power shelf controller. The credential-rotation engine gains a `DispatchVendor::Probe` path that resolves the power management controller (PMC) Redfish vendor via a bounded two-candidate authenticated probe, since the precise vendor is not persisted for power shelves. The site-wide `bmc_rotation_enabled` gate and the `TriggerBmcCredentialRotation` operator escape hatch are supported. (#4406) +- Added OpenTelemetry tracing to the BMC proxy, emitting per-request OTLP spans that capture the HTTP method, path, response status, and target BMC IP for each proxied call. The proxy now extracts inbound W3C trace context and injects the resulting span context into upstream Redfish and Carbide API requests, enabling end-to-end distributed tracing across BMC interactions. Tracing is disabled by default and can be enabled via TOML configuration or the `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` environment variable. (#4175) +- Added force-restart verification support for GB200 systems by inspecting BMC event log entries immediately after a force-restart is issued. The controller now confirms that the BMC recorded a `ForceWarmReboot` property-modification event before considering the restart operation complete, providing reliable restart confirmation for GB200 hardware. (#4376) +- Added support for per-VPC routing-profile overrides that can be specified at VPC creation time. Each explicitly supplied override replaces the corresponding value from the named base profile, while omitted properties continue to inherit from the base. The operator-controlled `internal` and `access_tier` properties cannot be overridden at the VPC level; the effective profile is resolved dynamically so API responses reflect any subsequent changes to the named base profile. (#4411) +- Added Provider-managed templated iPXE operating system support to the REST API, allowing Providers to create and manage templated iPXE OS definitions. Provider-created templated iPXE OS resources are now visible to Tenants, enabling Tenants to reference Provider-supplied OS configurations when provisioning hosts. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4067) +- Added host UEFI (BIOS) credential rotation support, mirroring the existing BMC credential rotation pattern. Pool hosts in the Ready state now converge their UEFI password to the site-wide target version through a new `RotatingHostUefi` top-level state, which drives an internal FSM through unlock, set, BIOS job creation, power-cycle, and re-lock steps. Hosts that fail rotation are quarantined with exponential backoff to prevent indefinite wedging. (#4424) +- Added support for an optional firmware-object URL in rack profiles, enabling automatic firmware updates during rack ingestion without requiring an explicit maintenance request. When a rack profile defines a firmware-object URL, NICo fetches and validates the JSON document at ingestion time and passes it through the existing firmware update path for the profile's compute and switch inventory. Explicit maintenance requests retain precedence, and profiles without a firmware-object configuration preserve the existing behavior of skipping firmware updates. (#4415) +- Added a rack-scale decommission workflow to the Flow service, enabling a single `DecommissionRack` call to drive the full decommission sequence across compute, NVSwitch, and power-shelf components in dependency order via Temporal. Each stage polls controller state until all components report `Decommissioned` before advancing; a failure in any stage halts subsequent stages without rolling back earlier ones. Each rack submitted to the workflow receives an independent task, allowing multiple racks to be decommissioned concurrently. (#4408) +- Added DHCP suppression for BMC MAC addresses marked with `suppress_dhcp = true` in the `ignored_bmc_macs` configuration. When a suppressed MAC is seen, the `DiscoverDhcp` RPC returns `FailedPrecondition` and atomically records a `dhcp_discover_suppressed_at` timestamp, which the decommission workflow uses to confirm the BMC DHCP client has returned to INIT state. Suppression is handled entirely within the existing `DiscoverDhcp` RPC without changes to the DHCP server binary. (#4459) +- Added logic to skip re-applying SetBootOrder when the boot configuration is already in the desired state, preventing redundant IPMI calls on each reconciliation cycle. +- Applied SetBootOrder boot configuration once per reboot cycle rather than on every controller reconciliation pass. + +### Changed + +- Extended the DHCP service to configure network interfaces with names beginning with `enx`, in addition to previously supported naming conventions. Operators deploying scout on hardware where network interfaces follow this naming pattern will now have those interfaces correctly configured. (#3045) +- Changed REST API container versioning to use the CI-supplied primary tag, removing the separate VERSION file that previously required manual maintenance. Set the OpenAPI schema version to 2.0.0. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3078) +- Added a VPC peerings table to the VPC detail page in the web UI, showing each peering relationship by ID with a link to the peer VPC's own detail page. The table is displayed when peerings exist and shows a distinct empty state when none are configured. (#3077) +- Changed firmware upgrade flows to apply database-backed host firmware configuration overrides on top of static and `metadata.toml` firmware catalogs, with database values taking precedence when they overlap. Runtime configuration now participates in version comparison and upgrade selection across firmware listing, desired firmware snapshotting, site exploration, host reprovisioning, machine update handling, and pre-ingestion. (#3061) +- Removed the unused `pytest.ini` configuration file, which only declared an `integration` marker not referenced anywhere in the repository. (#3083) +- Updated the pgx PostgreSQL driver dependency in the REST API service to resolve a security finding. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3062) +- Changed the per-reconcile firmware version mismatch log from a warning to a debug message during active firmware convergence, reflecting that the condition is expected rather than indicative of a failure. Corrected a persistent misspelling of "successfully" across log messages in several components including admin-cli, host-support, machine-validation, and ssh-console. (#3165) +- Changed log levels for BMC connectivity and event-log fetch failures during host and DPU restart verification from warning to debug, since these conditions are expected while a machine is rebooting. Structured fields (`machine_id`, `error`) were added to these log entries to improve machine-level filtering. (#3164) +- Renamed internal machine status test labels and subtests from the legacy Forge naming to NICo. (#3199) +- Added an opt-in site configuration option (`dpu_config.restart_ovs_on_use_admin_network_change`, default `false`) that causes DPU agents to restart `ovs-vswitchd` whenever a host transitions between admin and tenant networking. This ensures OVS picks up network mode changes in environments where it would otherwise retain stale behavior. New RPC and proto fields expose the `use_admin_network_changed` flag through `GetManagedHostNetworkConfig`. (#2540) +- Consolidated the Core protobuf definitions previously duplicated across the REST API and Flow services into a single canonical location at `rest-api/proto/core`. Regeneration is performed via `make -C rest-api core-proto`. (#3238) +- Squashed the `carbide-api-db` migration history into a single snapshot SQL file. Existing deployments migrate through the pre-squash migrations first (skipping any already applied), then continue with the post-squash migrations; new deployments apply the squashed snapshot directly. Old migration files are archived under a `pre-squash` directory. (#3288) +- Renamed the "Preingt State" column header in the `nico-admin-cli site-explorer get-report` output to "Pre-ingestion State" to match the spelling style of the other columns in the report. (#2592) +- Eliminated redundant deep copies of machine snapshot data when serving list and detail API responses. Snapshot data is now moved rather than cloned through the response pipeline, and database rows decode directly into their final form via `sqlx::Json`. Response content is identical; the change reduces per-request memory allocation on large machine lists. (#3222) +- Fabric manager clients are now built once and cached across calls rather than reconstructed on every operation. For `ib-fabric`, one UFM client is shared per fabric within a monitoring pass and reused across passes, rebuilding only when credentials, the endpoint, or TLS material on disk changes. For `libnmxc`, one channel per NMX-C endpoint is maintained across ticks with the same invalidation semantics. This eliminates repeated secret fetches, certificate reads, and TCP/TLS handshakes on busy fabrics, and ensures credential and certificate rotation heals automatically without a restart. (#3256) +- The DPA monitor and batch instance allocation now load all DPA interfaces for a host group in a single `machine_id = ANY(...)` query rather than issuing one query per machine. This reduces database round-trips from O(N) to O(1) per cycle and eliminates redundant host-snapshot clones during the allocation merge. (#3342) +- The per-host network-config poll now batches DNS domain and extension-service lookups, reducing database queries from approximately 8-9 per host (one per interface) down to one query for all domains and one query for all extension services per poll cycle. The per-interface "domain not found" behavior is unchanged. (#3343) +- Replaced several hot-path in-process count operations with targeted `COUNT(*)` database queries in compute-allocation, instance-create, pre-ingestion metrics, and network-segment drain code paths. This eliminates unnecessary full result-set transfers, Redfish report JSON decoding, and extra round-trips that previously occurred solely to determine a count. (#3387) +- Resource pool allocation now attempts the allocation statement directly and only consults pool accounting statistics when no row is returned, reducing a successful allocation from two database round-trips to one. The previous pre-scan query that checked pool capacity before every allocation attempt has been removed, as the allocation statement itself already signals exhaustion by returning no row. (#3398) +- Updated the `librms` dependency to v0.9.1 and aligned internal RMS mocks and test implementations with the expanded `RmsApi` trait. This update is behavior-neutral and prepares the codebase for eventual NVOS password rotation support; existing runtime behavior is unchanged. (#3405) +- Reduced the `ACCESS EXCLUSIVE` lock window during instance-address allocation by replacing sequential per-address INSERT statements with a single multi-row INSERT for all newly assigned addresses. For a dual-stack host with nine interfaces, this reduces approximately 18 sequential write statements under lock to one, improving concurrency for parallel allocation requests. (#3397) +- Optimized the logfmt log renderer to format each field once at record time rather than into separate heap-allocated strings that were subsequently sorted and re-copied into the output buffer. The carbide-api process no longer installs the admin UI live log-stream infrastructure (mutex, ring buffer, per-line allocation) when the admin UI is disabled. (#3396) +- Extended the DPU agent with Astra network configuration support via a new Weave EW VPC client and reconciler. The reconciler manages virtual networks and attachments by creating missing networks with deterministic IDs, moving and deleting virtual network attachments, and cleaning up stale objects, mapping Weave state to Astra configuration. (#3234) +- Removed the `[site_explorer] explore_power_shelves_from_static_ip` configuration flag; power shelves declared with static BMC IP addresses are now discovered through the standard site-explorer path without requiring the flag. Operators can remove this setting from their configurations as it is no longer recognized. (#3428) +- Added NVOS network information (IP address, MAC address, and port) to the Interfaces section of the switch detail page. (#3417) +- Standardized all count-style Prometheus metric descriptions to open with "Number of" for consistency across the codebase. Also corrected copy-paste errors in Vault client counter descriptions that incorrectly referred to TLS connections instead of Vault requests, and fixed grammatical errors in state-controller metric descriptions. (#3314) +- Enhanced the REST API local development stack launched by `make kind-reset` to support connecting to a locally built `nico-api` core instead of a mock backend. (#3371) +- Consolidated the `NoneIfEmpty` helper trait into `carbide-utils` and migrated all call sites to the shared implementation, removing duplicate empty-string-to-`None` conversion logic that had accumulated across multiple crates. (#3482) +- Renamed the iPXE template `Scope` concept to `Visibility` throughout NICo Core, aligning internal naming with the REST API and clarifying that the values mean `INTERNAL` (core-only) and `PUBLIC` (tenant-usable). (#3509) +- Updated the pull request template to include explicit guidance on writing context-rich descriptions that explain the motivation behind a change, consistent with the existing style guide requirement that PR descriptions assume no prior reader context. (#3421) +- Changed DPU BFB provisioning to use the BFB installer's native `BMC_REBOOT` feature instead of manually invoking a BMC reboot after firmware update, simplifying the post-install sequence and removing an explicit boot wait. (#3506) +- Changed the shared `/metrics` endpoint to encode the Prometheus registry on a single dedicated background thread rather than inline on the tokio worker serving each scrape connection. This caps metrics encoding to one CPU core regardless of how many concurrent scrapes arrive, preventing large scrapes from stalling tokio workers. (#3535) +- Updated internal documentation for previously merged changes. (#3512) +- Scoped the `error_message_case` xtask lint to scan only the `crates/` directory, matching the workspace member layout and avoiding false positives from external Rust source files in ignored directories. (#3617) +- Updated the Devspace deployment to no longer fail when the local Kubernetes cluster was not provisioned using the project's kind wrapper scripts. (#3614) +- Updated DPF setup documentation to include the required RBAC role for the `bluefieldsoftwares` resource. (#3438) +- Changed NVLink switch certificate rotation to route through the switch state machine rather than invoking RMS directly from the switch certificate monitor. This aligns certificate rotation with the same managed lifecycle used by other switch operations. (#3249) +- Excluded the generated metrics catalogue (`docs/observability/core_metrics.md`) from the docs CODEOWNERS rule so that metric-only changes no longer require a technical-writer review approval. (#3625) +- Updated the `lint-error-messages` xtask to exclude tonic-generated files from error-message style checks, and corrected existing violations in non-generated source files that had accumulated since the check was introduced. (#3660) +- Added a CI check that validates PR descriptions are non-empty, free of unexpanded HTML template comments, and meaningfully filled out beyond the bare template skeleton. (#3552) +- Fixed machine validation deadlocks by aligning lock acquisition order across result persistence and stale-attempt reconciliation code paths so that concurrent transactions cannot form a cycle. (#3533) +- Changed the DPU agent to enable LLDP-MED in `/etc/defaults/lldp` and removed the management interface restriction so LLDP now runs on all interfaces including the management one. These changes support automated cable validation workflows. (#3692) +- Changed the default web frontend authentication mode from unauthenticated to basic authentication, following the precedent of projects such as Grafana and ArgoCD. The Helm chart now generates a random initial admin password via Kubernetes when none is explicitly configured, ensuring that out-of-the-box deployments are protected by credentials rather than left open. (#3492) +- Updated documentation for the entity manager default value and added a warning note for deployments where DPF is not in use. (#3656) +- Changed `tenant_organization_id` on OS objects created via the gRPC API to be optional, enabling explicit provider vs. tenant ownership attribution during REST layer reconciliation. When `tenant_organization_id` is present the OS is treated as tenant-owned; when absent it is treated as provider-owned, replacing the previous implicit provider-only behavior. (#3689) +- Improved the `txn_held_across_await` lint to track inner transaction lineage, correctly exempting awaited functions that receive an inner transaction derived from the outer one via a begin statement and eliminating several previously required allow annotations. (#3999) +- Overhauled the firmware documentation with updated content and improved organization. (#3670) +- Updated README documentation links to point to the correct in-repository paths for the overview (`docs/overview/what-is-nico.md`) and quick-start (`docs/getting-started/quick-start.md`) guides while retaining a separate link to the published NICo web documentation. (#3773) +- Bumped crate versions for libredfish and nv-redfish. (#4203) +- Updated CODEOWNERS to reflect current team membership for Helm chart ownership. (#4253) +- Introduced a first-class `DeviceId` type in `carbide_uuid` that unifies `MachineId`, `SwitchId`, and `PowerShelfId` for contexts where any device identifier is valid, removing the need for separate `--machine-id`/`--switch-id` CLI flags in admin commands that accept any device type. (#4381) +- Added a Rust-based code generator that produces `DpuServiceConfiguration` and `DpuServiceTemplate` manifests for the `doca-weave-dhcp-agent` and `doca-weave-flow-controller` DPF services. This replaces previously manual or separately maintained configuration artifacts with generated outputs, ensuring consistency between service templates and their corresponding configurations. (#4404) +- Changed the boot-interface update mechanism to be declarative and database-authoritative, replacing the previous approach that mixed synchronous database writes with Redfish calls. The primary interface, admin address ownership, network versions, and desired boot-interface target are now committed in a single lock-ordered transaction, after which the machine controller is woken to reconcile the Redfish state asynchronously. This eliminates the possibility of the BMC and NICo disagreeing on the active boot interface when a Redfish call succeeds but a subsequent database write fails. (#4434) +- Extended integration test coverage by migrating unit tests to integration suites and adding regression tests for rack firmware upgrade, power management, provisioning flows, and BMC exploration scenarios (#3076, #3079, #3116, #3183, #3187, #3248, #3278, #3246, #3318, #3271, #3413, #3393, #3395, #3629, #3776, #3842, #3847, #3979, #3959, #3963, #3966, #3971, #3972, #3973, #3976, #4054, #4050, #4048, #4060, #4065, #4056, #4043, #4010, #4062, #4073, #4074, #4080, #4095, #4090, #4086, #4173, #4185, #4209, #4228, #4230). +- Performed internal code-quality refactors including extracting shared instrumentation counters, consolidating boot NIC resolution, modularizing controller actors, and improving code organization with no behavior change (#3113, #3433, #3437, #3450, #3448, #3449, #3460, #3454, #3523, #3527, #3525, #3479, #3458, #3566, #3595, #3613, #3653, #3453, #3720, #3743, #3739, #3740, #3742, #3745, #3746, #3747, #3748, #3741, #3752, #3801, #3802, #3800, #3799, #3828, #3829, #3830, #3831, #3837, #3840, #3838, #3839, #3851, #3860, #3864, #3870, #4066, #4063, #4284, #4310, #4328, #4366, #4379, #4391, #4445). +- Maintained the CI/CD and release-artifact pipeline, including artifact build-chain gating, container registry parameterization, and routine security-scan pin updates (#3052, #3126, #3006, #3242, #3229, #3355, #3257, #3621, #3727, #3827, #4030, #3808, #4111, #4133, #4198, #4197, #4262, #4295, #4320, #4329, #4332, #4292, #4040, #4369, #4433, #3578). +- Updated third-party library dependencies including multiple libredfish releases (#3442, #3597, #4269, #4270). +- Expanded operator and contributor documentation covering quick-start guidance, DPU configuration, CLI flag corrections, architecture context, and code-review process (#3048, #3114, #3111, #3031, #3134, #3135, #3138, #3263, #3097, #3399, #3443, #3185, #3104, #3377, #3353, #3503, #3285, #3277, #3513, #3604, #3635, #3306, #3225, #3373, #3498, #3606, #3631, #3462, #3647, #3650, #3768, #3767, #3707, #3648, #3685, #3651, #3652, #3473, #4148, #3007, #4112, #3637, #4307, #4223, #4261, #3628, #4345, #4456, #3876). + +### Deprecated + +- The REST API layer for network segments (subnets) has been updated to consume the new structured `config`, `status`, and `metadata` sub-messages from the Core gRPC proto, replacing the now-deprecated flat top-level fields. Consumers that read subnet data from flat fields should migrate to the structured equivalents, as the deprecated fields are no longer populated by the REST API. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3607) +- The REST API layer for VPCs has been updated to consume the new structured `config` and `status` sub-messages from the Core gRPC proto, replacing the now-deprecated flat top-level fields. Consumers reading VPC data from flat fields should migrate to the structured equivalents, as those fields are no longer populated by the REST API. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3565) +- Changed `nico-admin-cli` configuration file lookup to prefer `$HOME/.config/nico_api_cli.json`, aligning the tool's runtime behavior with its documentation. The legacy `carbide_api_cli.json` filename is still accepted as a fallback but now emits a deprecation warning; operators should rename their configuration files to `nico_api_cli.json`. (#3599) +- Separated `forge.Machine` gRPC proto fields into `MachineConfig` (operator-set desired state: maintenance, instance-type, firmware policy, DPF toggle) and `MachineStatus` (system-observed state) sub-messages, following the same convention as other resource types. The original flat fields are retained as deprecated proto aliases so existing REST API consumers are unaffected until a follow-up migration removes them. (#2847) +- Migrated NICo's RMS requests from the closed `NodeType` enum to the open `NodeDescriptor` format, which passes the rack-profile role, vendor, and product family as arbitrary strings directly to RMS for dispatch resolution. This eliminates the need for a NICo release solely to extend the enum mapping when new hardware families are added. `NodeType` and `NodeDescriptor` currently coexist with `NodeDescriptor` serving in the fallback path; `NodeType` is deprecated and will be removed in a future release. (#3812) +- The Scout version for a machine is now surfaced as `scoutVersion` within the machine's status object. The previous top-level `scoutVersion` field is deprecated and retained as a compatibility fallback; operators should migrate to reading the field from the status block. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4136) +- Deprecated the BMC MAC address update field on `ExpectedMachine` PATCH requests, as NICo Core uses the original BMC MAC as machine identity and accepting changes could leave REST and Core in disagreement. Physical MAC changes are now rejected before any write or workflow is executed; omitted or format-equivalent values continue to work for backward compatibility. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4317) + +### Removed + +- Deprecated the `isCloudInit` field on operating system create and update API requests; the field is no longer stored in the database and its value is now derived automatically from the presence of cloud-init user data. The field remains present in API responses but reflects computed system behavior rather than a caller-supplied value. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3102) +- Removed the deprecated `machine_id` field from `InvokeInstancePower` gRPC requests; callers must now identify the tenant instance exclusively by `instance_id`. The removed field name and number are reserved to prevent future reuse, and the admin CLI, REST API, control-plane workflow, and site workflow paths have all been updated accordingly. (#2948) + +### Fixed + +- Fixed BMC explorer to treat B4240V chassis as BlueField-4 hardware, preventing Redfish BootOptions fetches that fail when the endpoint returns a null Members list. This resolves exploration failures specific to BlueField-4 variants in the B4240V form factor. (#3053) +- Fixed error reporting for missing-vendor BMC exploration failures to produce clearer diagnostic messages. Added a circuit breaker for BMC network connections to prevent repeated connection attempts to unreachable BMC hosts, improving reliability and reducing log noise during network-level outages. (#2980) +- Fixed a mismatch between the OpenAPI schema and the actual DPU reprovisioning route URL, where the schema documented `dpu-reprovision` but the route used `dpu/reprovision`. Clients relying on the previously documented path were unable to reach the endpoint. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3063) +- Fixed BlueField-4 DPU part number detection on Vera Rubin NVL72 trays, where the product part number is exposed on `Chassis/Bluefield_BMC` or `Chassis/BlueField_BMC_0` rather than `Card1`. Also corrected identification of host tray SKUs with the `900-9D4A4` prefix that were not previously recognized as BF4 hardware. (#3055) +- Added `RedfishVendor::VeraRubin` to restore compatibility with libredfish changes and bumped the libredfish dependency version. This ensures correct Redfish vendor identification for Vera Rubin hardware. (#3074) +- Updated the BMC mock to correctly handle BlueField-4 Nvidia OEM endpoints that do not provide `BaseMac` and `NicMode` attributes at the `/redfish/v1/Systems/Bluefield/Oem/Nvidia` path, improving test coverage accuracy for BF4 hardware variants. (#3072) +- Normalized all eight state-history tables around a common five-column schema with an `object_id` resource key, making timestamps mandatory and backfilling existing null values. Removed cascading resource foreign keys so that history records are retained after the associated resource is deleted. Updated shared accessors, joins, retention triggers, and indexes to reflect the new layout. (#2957) +- Fixed a scout discovery hang where hosts without a TPM device (`/dev/tpmrm0` absent) would loop indefinitely in `WaitingForDiscovery` because an unconditional `TPM2_Clear` call hard-failed during the discovery deprovision phase. Scout now checks for the presence of the TPM device before attempting to clear it, skipping the operation on TPM-less hosts while preserving the hard-error behavior for present TPMs that fail to clear. (#2703) +- Fixed a validation bypass where supplying `prometheus.scrapeIntervalSeconds: 0` was incorrectly accepted with a 201 response due to Go-ozzo skipping rules on zero-value fields without a `Required` constraint. The API now correctly enforces the minimum value of 1 for the scrape interval. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3108) +- Updated the OpenTelemetry dependency to version 0.32.1 to resolve a security vulnerability. (#3086) +- Fixed a regression introduced by recent refactors that prevented Network Security Groups from being detached from VPCs. Also corrected equivalent handling for NVLink partition ID updates in the REST layer. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3147) +- Renamed and restructured the Machine health report, BMC reset, and DPU reprovisioning endpoints to align with existing REST API naming conventions. Handler names, API paths, and model ToProto/FromProto structures were updated across all three endpoint groups. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3150) +- Fixed a bug where a DHCP record lookup that returned no rows was surfaced as an internal server error (HTTP 500) rather than a clean not-found response. The lookup now correctly returns an absent result when an interface's allocated address has no containing prefix or no address of the requested family, and `discover_dhcp` responds with a `NotFound` status. (#3163) +- Changed the `forge-dpu-otel-agent` binary to emit logs in logfmt format, aligning its output with all other NICo DPU components. Operators relying on the previous log format will need to update any log parsers or dashboards that consumed the old structured output. (#3188) +- Fixed Redfish endpoint URL construction for NV-Switch BMCs with IPv6 addresses. Previously, bare IPv6 literals in the URL authority produced invalid URLs that prevented the Redfish client from connecting to any IPv6-addressed NV-Switch BMC. IPv4 addresses and hostnames are unaffected. (#3013) +- Fixed the NICo CLI to correctly detect and surface errors in malformed configuration files rather than silently proceeding. Improved usage help text for commands that accept parameters to more clearly communicate available options. (#3196) +- Added support for the updated Redfish resource IDs introduced in newer BlueField-4 firmware, covering system, manager, and product chassis identifiers. The product BMC chassis is now used as the authoritative source for BF4 identity and pairing serials. Legacy BlueField Redfish IDs are still recognized for backward compatibility. (#3117) +- Switched the InfiniBand reset and configure path in scout from `mstconfig` to `mlxconfig`. The previous tool did not function correctly on ConnectX-8 cards; `mlxconfig` provides compatible behavior across GB300, CX8, and IB hardware. (#3233) +- Added a 10-minute container startup timeout for extension service deployments on the DPU agent. When the timeout expires without a running container — such as after a silent image pull failure that leaves the service in a permanent `Pending` state — the extension service is now reported as `Error` rather than remaining stuck indefinitely. (#3236) +- Fixed the `legacyAlias.aliases[].createNamespace` Helm value to default to `false`, preventing the chart from rendering a Namespace that `helm-prereqs` already owns. Previously, dual ownership caused Argo CD to flap both Applications `OutOfSync` indefinitely, and in the worst case automated pruning could delete the entire namespace and cascade-destroy all resources within it. (#3197) +- Fixed `make kind-reset` in the REST API service so that it correctly resets and relaunches the local development environment. (#3239) +- Fixed instance network config validation for multi-NIC zero-DPU hosts that use `auto: true` network configuration. Previously, the validator incorrectly interpreted the resolved bare `Physical {}` interfaces — one per `HostInband` segment — as duplicate PFs of a single device and rejected the config, breaking instance config updates on affected hosts. Resolved auto configs are now validated against segment identity rather than device function identity. (#3261) +- Fixed the expected-switch REST API to manage `nvosMacAddresses` end to end. `POST /expected-switch` and `PATCH /expected-switch/{id}` now accept the field, validate each entry as a MAC address, reject duplicates, and deliver the value to Core through the site workflow. `GET` responses return it, and inventory reconciliation keeps it synchronized when the site changes. Previously, a REST-created switch reached Core with no NVOS MACs, stalling ingestion in the switch controller, and any REST-driven update silently cleared MACs that had been set through the CLI. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3273) +- Fixed the `POST /expected-machine` endpoint to return HTTP 400 with a descriptive error message when the request omits or provides an invalid Site ID. Previously this condition produced an HTTP 500 response. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3275) +- Fixed host serial number retrieval for VeraRubin systems to read from the assembly path, matching the existing approach used for GB200 hardware. (#3292) +- Implemented firmware status retrieval for compute trays, which previously returned no firmware status information for that hardware class. (#3310) +- Fixed the machine state machine to handle predicted hosts in the `Created` state without logging spurious ERROR-level messages. Previously, every reconcile of a predicted host in `Created` emitted an "invariant violation" error and an `InvalidHostState` result, producing hundreds of false-positive error log entries per hour. Predicted hosts now wait quietly in `Created` at debug level until discovery promotes them; machines genuinely stuck in `Created` still surface through the existing state SLA machinery. (#3167) +- Added uniqueness enforcement for NVOS MAC addresses across expected switches. Core now rejects a registration or update request if any of the supplied NVOS MACs is already claimed by a different expected switch, and the REST API returns a `409 Conflict` response in that case. Previously, two expected switches could silently share a MAC, causing mis-addressed management ports or duplicated switch-search records that only surfaced during discovery. (#3293) +- Fixed two defects in `setup.sh` that left a freshly bootstrapped site invisible to the REST API. The site-agent bootstrap Job now seeds the REST database with a site record so that the agent's inventory is accepted rather than dropped. Additionally, the workflow subchart's worker database target was corrected after the `nico-pg-cluster` consolidation left it pointing at a legacy database with no schema, causing every workflow database operation to fail. (#3284) +- Fixed scrubbing to proceed normally on Lenovo RAID kits when no RAID array is defined. Previously, the absence of an existing array returned an error; now the scrubbing workflow skips the RAID check and proceeds directly to disk erasure, returning an error only if the erasure itself fails. (#3334) +- Fixed a race condition in the NVLink Logical Partition inventory update loop where a concurrent inventory pass could overwrite a `Deleting` partition status with `Ready`, preventing the partition from being cleaned up. A guard now skips status updates for partitions already in `Deleting` state, matching the existing guard in the InfiniBand Partition processor. See https://nvidia.github.io/infra-controller/ for the updated schema. (#2674) +- The nico-pxe service now derives `CARBIDE_API_INTERNAL_URL` from the configured nico-api service host and port rather than falling back to a hardcoded `carbide-api` hostname. This ensures the PXE service connects using the correct mTLS certificate name that matches the deployed API service. Deployments that require a custom internal API URL can still override this via `extraEnvData`. (#3330) +- Fixed a bug where Dell iDRAC's practice of duplicating BlueField part numbers and serial numbers onto unrelated PCIe records caused Site Explorer to ingest the same physical DPU twice during host ingestion. Site Explorer now tracks BlueField serials within each host pass and skips duplicate records with a warning log, ensuring each physical DPU is processed exactly once. (#3356) +- Fixed gRPC call latency measurement in site-agent workflow activities, which was defined but never actually recorded. Each gRPC call to NICo from workflow activities is now timed and logged, providing accurate per-call latency data for operational monitoring. (#2702) +- Fixed `mlx-devices` to correctly separate product SKU from operating mode when classifying BlueField devices. The `kind` label now reflects the factory SKU ("BlueField-3 DPU" or "BlueField-3 SuperNIC") while `nic_mode`, read from the DPU BMC, represents the authoritative operating mode. The `--nic-mode-only` filter now uses `nic_mode` as the primary discriminator, falling back to SKU classification only when the operating mode is unknown. (#3346) +- Machine validation now detects and self-corrects a drifted boot device configuration while waiting for the host to boot into the validation environment. When the boot config is found to have reverted — due to external modification, a BIOS quirk, or NIC inventory loss during POST — validation unlocks the BMC, re-drives the full boot-order flow, re-locks, and resumes from its reboot step. Previously, a drifted boot config at this stage was unrecoverable because BMC lockdown from HostInit blocked any corrective action. (#3369) +- Fixed the operating-system PATCH endpoint to correctly enforce immutability of `imageUrl` and `imageSha`: attempts to change these fields now return a `400` error immediately with a clear message rather than propagating to Core where they would fail with a less informative error. `imageAuthType` and `imageAuthToken` can now be updated independently without re-sending `imageUrl`/`imageSha`. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3294) +- Fixed a deadlock in `AdminForceDeleteMachine` caused by acquiring `machine_interface` rows before explored-host tables while concurrent writers — site-explorer, DPU discovery, and the allocator — acquire locks in the opposite order. All conflicting write paths now acquire locks in a consistent order, eliminating the circular dependency that caused Postgres to detect and abort the transaction. (#3364) +- Updated BMC credential guidance to use REST-based credential management as the primary approach rather than legacy IPMI-based methods. (#3237) +- Fixed a mistype in the hardware health classification logic where `HealthClassification` evaluated sensor readings against `range_min` instead of `lower_fatal` when determining Fatal state. Sensor readings that fall below the lower fatal threshold are now correctly classified as Fatal. (#3401) +- Fixed BF3 and BF4 `DPUServiceTemplate`, `DPUServiceConfiguration`, and `NAD` custom resource names colliding in the shared namespace when both deployments are active simultaneously. BF4 CR names are now suffixed per deployment while BF3 retains its original unsuffixed names, preventing each deployment from overwriting the other's Helm values and service versions. (#3404) +- Fixed a database health-check bug in the `WorkLockManager` where `db.ping()` returned success even when the service was connected to a read-only replica following a failover event. Error handling now detects read-only replica connections and triggers an explicit reconnect, preventing stalled work locks after database failover. (#3328) +- Fixed DPU type detection to recognize the `Bluefield-4` product name that appears on BlueField-4 devices following a firmware update, in addition to the previously recognized product identifier. (#3441) +- Fixed a Vault client metrics bug where a failed `get_credentials` read incorrectly incremented both the failure and success counters. The `VaultRequestSucceeded` event is now emitted only on a genuine successful credential read, restoring the invariant that `attempted == succeeded + failed` on all code paths. (#3467) +- Fixed inconsistent Prometheus HELP text for `carbide_dhcp_replies_sent_total`, which was declared with divergent descriptions in the DHCP relay and standalone DHCP server binaries. Both crates now register identical HELP text, eliminating scraper-visible inconsistency when collecting from either process. (#3466) +- Fixed BMC firmware version reading for BlueField-4 devices, which report a version string prefixed with `bf4-` and expose the BMC firmware at a different Redfish endpoint (suffixed with `FW_BMC_0`) compared to BlueField-3. (#3477) +- Fixed doubled `_total` suffixes on DSX exchange consumer Prometheus counters (e.g., `carbide_dsx_exchange_consumer_messages_received_total_total`) caused by names that already ended in `_total` being processed by an exporter that appended another. Metrics are now exported with single `_total` suffixes as intended. (#3465) +- Added support in the BMC explorer for Delta power shelves, enabling their discovery and management through the standard site-explorer path. (#3455) +- Fixed a hardware health bug where a BMC self-reporting an `Ok` status suppressed all independent sensor threshold alerts, including `Critical`, `Fatal`, and `SensorFailure` classifications. The BMC-`Ok` suppression now applies only to `Warning`-level alerts, ensuring critical and fatal sensor events are always raised regardless of the BMC's self-reported health. (#3440) +- Fixed NVLink topology grouping to fall back to the first GPU platform chassis serial from the machine topology when `nvlink_info` is missing or empty. This allows MNNVL-capable hosts to be correctly grouped and have `nvlink_info` populated from NMX-C hello messages even when the field is not explicitly set. (#3483) +- Fixed DHCP routing for hosts operating in NIC mode or with zero DPUs by declaring their host interfaces as `HostInband` and routing direct DHCP requests through the configured HostInband relay. The fix preserves Admin fallback compatibility and transitions managed hosts to the new routing only after confirming a DPU-to-NIC mode change. (#3486) +- Added an explicit migration signature recovery mode that allows the service to start when an installed migration file's recorded hash no longer matches the file on disk (for example, after a copyright header change). Recovery updates only the stored hashes within a locked transaction without re-executing any migration SQL, while migrations that have not yet run proceed through the normal application path. The recovery mode is activated via a hidden `db migrate` flag or a service startup environment variable. (#3511) +- Added a `patch-hbn-manifest.py` script applied during DPU provisioning to fix six known bugs in the DOCA HBN 3.2.2 `doca_hbn.yaml` manifest, including infinite loop conditions in the `init-sfs` init container on restart. This patch is specific to DOCA 3.2.2 and must be reviewed or removed when upgrading to a newer DOCA version. (#3507) +- Fixed Debian package version stamping to respect the `VERSION` override variable used by `carbide-api`, ensuring that package versions are consistent with the binary version at build time. (#3508) +- Fixed machine-a-tron's control API (Web UI and `/machines/status` endpoint) to be available in both combined and per-IP BMC registration modes. Previously the control routes were only registered under the combined BMC startup path, making them unreachable when each simulated BMC used its own per-IP listener. (#3532) +- Removed the unsupported `HIDE_PORT2_PF` parameter from the BlueField-4 DPF flavor configuration, which caused provisioning failures on BF4 hardware. (#3538) +- Fixed a bug where site-explorer permanently cached an incomplete Redfish service root returned by a BMC during reset or boot, causing all subsequent explorations to fail with "BMC has not provided chassis collection". The service root cache now rejects and discards incomplete entries so that a full root is fetched on the next exploration attempt. (#3551) +- Fixed a bug where `assign-address` and `remove-address` CLI operations skipped the hostname-resync step, leaving an interface's hostname pinned to its previous IP address. The stale hostname record could then wedge all new DHCP allocation on the segment by colliding with the unique FQDN constraint when the freed address was reused. (#3515) +- Fixed an incorrect `Syncing` status reported for SSH key groups that have no associated site to synchronize with. SSH key groups not linked to any site now correctly reflect a terminal non-syncing state. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3567) +- Fixed the rack state controller silently ignoring its configured iteration parameters and running on default values. The missing `iteration_config` wiring is now applied so operator-configured intervals and timeouts take effect. (#3559) +- Fixed a bug where a failed timestamp write after a successful BMC reset caused the reset to be counted as a failure, triggered a redundant second reset via IPMI on the Redfish path, and allowed the rate-limit throttle to re-issue the reset approximately 120 seconds later. Each reset function now returns success once the BMC is physically reset and surfaces timestamp write failures as a separate warning. (#3562) +- Fixed Lenovo GB300 network boot configuration to disable competing PXE and UEFI HTTP boot options that caused firmware to select an unintended network interface. Updated libredfish to v0.44.20, adjusted the GB300 PXE retry expectation, and added a machine setup mismatch report when the selected UEFI boot option is disabled. (#3582) +- Corrected the `nicocli site list` documentation to specify that `NICO_API_NAME` must be set to `nico` before running the command. Without this, the variable defaults to `carbide` and the command returns a 404 error. (#3264) +- Fixed a race condition between clearing a site exploration error and a concurrent in-flight exploration update. The clear operation now locks the endpoint row and increments its version, ensuring the error remains cleared regardless of which operation commits first. (#3555) +- Fixed instance configuration updates sent in the legacy `InstanceNetworkConfig.auto: true` wire format being incorrectly rejected as an immutable-network change. The update path now translates the deprecated `auto` boolean into the current `auto_config` representation, preserving automatic networking for components still emitting the older format during rolling upgrades. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3594) +- Fixed stale Redfish service root cache entries persisting indefinitely after a BMC reset or reboot. Cache entries are now expired so that subsequent explorations fetch a fresh service root rather than reusing a stripped or incomplete cached response. (#3580) +- Fixed a security issue where MCP credentials inherited from the server configuration could be forwarded to unintended origins. Inherited credentials are now pinned to the configured REST origin, caller-selected destinations must match that origin when one is set, and cross-origin redirects are rejected before credentials can reach the redirect target. (#3499) +- Fixed inventory linking and drift detection to use BMC MAC address as the stable machine identifier instead of chassis serial number. On Lenovo GB300, DMI and Redfish serial numbers are disjoint, which caused compute linking failures and false drift alerts; the BMC MAC address is consistent across both sources and is now used as the linking key for compute, NVSwitch, and PowerShelf components. (#3544) +- Fixed build failures in `fmds`, `dsx-exchange-consumer`, and `spdm-controller` caused by four instrumentation events that still used the now-removed bare `name` key after the `event_name`/`metric_name` split. No metric names or behaviors changed. (#3649) +- Fixed duplicate error messages appearing in logs when a `CarbideError` was converted to a gRPC status. The error is no longer logged at conversion time; instead it is attached to the status via `set_source` so the existing request-span log layer emits it exactly once when the request completes. (#3619) +- Fixed the Devspace machine-a-tron Docker build by allow-listing the IPMI simulator chassis-control script in the `.dockerignore` file so it is included in the build context. (#3627) +- Fixed the `ExpectedMachine` PATCH endpoint to correctly distinguish between an omitted `bmcIpAddress` field (preserve the current value) and an explicit `null` value (clear the address). Both individual and batch update handlers now route explicit null through the existing clear path while leaving non-null values and omitted fields unchanged. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3678) +- Fixed the REST `ExpectedMachine` view to stay synchronized with BMC IP address changes that originate from Core during the normal inventory pass, without requiring a subsequent REST PATCH to propagate them. Address sets and changes are now applied via `ExpectedMachineDAO.Update` and removals via `ExpectedMachineDAO.Clear`, both within a per-machine transaction. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3701) +- Disabled a flaky `dpu-to-nic-mode` integration test pending investigation of a race condition where MAC address re-creation and re-ingestion can occur before the mode transition completes. (#3710) +- Fixed a deadlock in integration tests where concurrent transactions writing to multiple explored endpoints used inconsistent lock ordering; all such transactions now acquire locks in sorted order. (#3695) +- Fixed `forge-dhcp-server` to accept explicit command-line flags for the Carbide API root CA, client certificate, and client key, replacing hardcoded `/opt/forge` certificate paths. The existing paths remain as defaults so currently deployed configurations are unaffected, while environments that mount certificates at different locations can now supply them at startup. (#3704) +- Fixed exploration and management of Supermicro MGX C2 systems (NVIDIA PG535/2G535 processor module) by detecting the platform, skipping KCS exploration since MGX C2 uses SSIF, and evaluating Supermicro lockdown consistently with libredfish. The existing `ARS-121L-DNR` HostInterface PXE exception is preserved. (#3675) +- Fixed the `nico-dns` Kubernetes Service to request a dual-stack `ClusterIP` by adding `ipFamilyPolicy: PreferDualStack` to both the Helm chart template and the kustomize base manifest. This provides the IPv6 cluster address that DPU `resolv.conf` entries and DHCPv6 RDNSS option 23 advertisements point to, while `PreferDualStack` ensures the Service still deploys successfully on IPv4-only clusters. (#3646) +- Fixed PXE provisioning to seed a NoCloud `network-config` document reflecting tenant-provided network settings, ensuring cloud-init applies operator-specified network configuration during initial boot. (#3392) +- Fixed a panic in the inventory-sync workflow activity that occurred when a site reported a GPU config with a nil `NVLink LogicalPartitionId` wrapper. The field accessor has been changed to the nil-safe generated `.GetValue()` method, which returns an empty string instead of dereferencing a nil pointer and crashing the entire inventory-sync job. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3725) +- Fixed `nico-admin-cli` expected-machine JSON imports to accept `id` fields serialized as RPC UUID objects (`{"value":"..."}`) in addition to plain strings and absent IDs. (#3338) +- Fixed two security vulnerabilities in the `DiscoverMachine` endpoint: callers could previously supply a `machine_interface_id` that the server accepted without verification, and could obtain another machine's certificate by providing replicated discovery information paired with a different target machine ID. Production deployments now derive the machine interface ID exclusively from the source IP; a new `allow_insecure_discovery` configuration flag must be explicitly set for integration test environments that cannot simulate source IPs. (#3561) +- Fixed the TPM EK NV fallback to probe only the standard RSA (`0x01c00002`) and ECC (`0x01c0000a`) EK certificate NV indices used by deployed tool versions, concatenating the raw buffers in tool order before hashing. Previously the fallback could trim NV padding or include indices unused by the deployed tool, producing a host ID that differed from the one NICo normally derives. (#3434) +- Fixed the fast-path machine-interface creation error message to omit the `NetworkPrefix.num_free_ips` field, which was always reported as zero because the DHCP discovery path does not request that computation. The error now lists the names and IDs of affected network segments without exposing uncomputed fields that could lead operators to incorrectly diagnose address-pool exhaustion. (#3703) +- Fixed a crash loop in `carbide-api` triggered by an out-of-range MTU value in the site configuration. Instead of failing on a database constraint violation at startup, the service now validates MTU values before any database write and emits a clear diagnostic message naming the network and the invalid value. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3751) +- Fixed parsing and rendering of IPv6 addresses in `HostPortPair`. The parser previously split on every `:`, causing all forms of IPv6 host addresses — bracketed, bare literals, and loopback — to be rejected, making it impossible to configure an IPv6 BMC proxy via the `site-explorer.bmc_proxy` dynamic setting. The `Display` implementation also rendered IPv6 hosts ambiguously, breaking round-trip serialization; both defects are now resolved. (#3012) +- Fixed the BMC proxy building invalid URI authorities when connecting to IPv6 BMCs. Bare IPv6 literals in the upstream URI authority are now bracketed correctly (e.g., `[2001:db8::1]:port`), preventing connection failures to any IPv6-addressed BMC. IPv4 addresses, hostnames, and already-bracketed IPv6 literals pass through unchanged. (#3010) +- Fixed inconsistent error handling for empty and malformed filter parameters on the VPC peering list endpoint. All five query filters (status, vpcId, peerTenantId, siteId, isMultiTenant) now uniformly return HTTP 400 for present-but-empty values, and a malformed siteId UUID now returns 400 instead of 500, consistent with how other UUID filters already behaved. (#3771) +- Updated the BF4 DPU flavor definition to match the configuration used by the DPF team, resolving a discrepancy that could cause provisioning inconsistencies in mixed-generation DPU deployments. (#3772) +- Fixed a race condition during first-run NICo setup where `vault status` could return empty output and abort `setup.sh` with an error even though Vault pods were healthy, because pods reach the `Initialized` condition before the listener accepts connections. The Vault status check now retries with configurable attempts and sleep intervals (defaulting to 36 × 5 s) and validates the JSON payload before proceeding, eliminating the need to re-run `setup.sh` on a healthy cluster. (#3680) +- Fixed inaccurate free IP count reporting for IPv6 networks. The previous `u32` representation saturated for any prefix with more than ~4 billion addresses (anything larger than a `/96`), causing operators to see a capped and incorrect available-address count for IPv6 segments. Counts are now tracked per-prefix as `u128`, with a dedicated `FullIpv6Space` variant for a complete `/128` address space, while wire compatibility with existing clients is preserved. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3750) +- Fixed an inverted condition in DPU extension timestamp parsing that caused successful parses to emit error log entries while genuine parse failures were silently dropped. Non-empty parse failures are now logged correctly, and the existing fallback timestamp is preserved on failure. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3744) +- Fixed several code paths that passed bare IPv6 BMC addresses across URI authority and `Forwarded` header boundaries without the required bracketing. Endpoint exploration, the admin browser, Redfish actions, `libredfish`, and proxy paths now bracket IPv6 literals at the correct protocol boundary, producing valid URIs (e.g., `[2001:db8::1]:443`) and RFC 7239-compliant `Forwarded` header values. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3749) +- Fixed Temporal namespace creation in `setup.sh` to be fully idempotent by checking for namespace existence via `temporal operator namespace describe` before attempting creation, rather than relying on the create call failing with an "already exists" error. This ensures that real connectivity, authentication, or TLS failures are propagated with diagnostic context rather than silently suppressed. (#3679) +- Expanded preflight validation to check manifest pull access for the exact NICo Core image references that `setup.sh` will deploy, using the Docker Registry v2 API with the same credentials and conventions as setup. Previously, preflight only verified registry reachability, so invalid credentials were not detected until the `nico-api-migrate` pre-install job entered `ImagePullBackOff` late in the installation sequence. (#3681) +- Fixed a race condition in DPF-requested power cycle handling where ForceOff and power-on commands were issued and their results checked in the same tick, giving the BMC no time to act. A configurable delay is now enforced after each power command before reading back the power state, the command is retried up to three times if the power state does not change, and all DPUs on the affected host have their state advanced together on a host power cycle. (#3779) +- Added startup validation to machine-a-tron that immediately fails configuration when IPMI simulation is enabled but the `ipmi_sim` executable is missing or not executable in `PATH`. Previously, this was discovered only when constructing an IPMI-capable BMC, which could obscure the configuration problem and repeatedly replace partially registered mock BMC state. (#3753) +- Added download URLs to SoftwareInventory entries displayed in the UI and CLI, allowing operators to directly retrieve the referenced software artifacts from inventory listings. (#3781) +- Fixed the pre-ingestion unified BFB artifact being created with world-readable permissions. The artifact embeds the BMC root password in cleartext, so it is now created with `0600` permissions set atomically at file creation time, independent of the process umask. (#3688) +- Fixed a runtime panic in the nv-redfish client pool when connecting to IPv6 BMCs. Bare IPv6 literals passed to `Url::parse` produced an invalid URI authority (e.g., `https://2001:db8::1:8443`), which caused the `.expect()` call to panic. All URL construction paths in the pool now bracket IPv6 literals before appending the port, matching the bracketing already applied on sibling code paths. (#3008) +- Fixed the NVLink manager incorrectly removing GPUs from the tray partition when a tenant adds only a subset of a tray's GPUs to a tenant partition. The manager now checks whether the remaining GPUs should still belong to the tray partition before removing them, preserving the correct partition membership for unaffected GPUs. (#3844) +- Removed a duplicate key entry from the devspace Helm values file that was introduced when two PRs independently added the same key. (#3793) +- Fixed two DPF reliability issues for BF4 DPUs: incomplete service inventory snapshots are now rejected when referenced DPUServiceTemplate CRs are unavailable, preserving the last-known-good database value rather than overwriting it with partial data. The DPF reboot power-on intent is also now persisted before issuing or retrying the power command, preventing the persisted state from diverging from hardware state after a failure. (#3845) +- Fixed the simple SDK leaving behind auto-created SSH key groups when deleting an instance that was provisioned with SSH keys. The SDK now identifies groups created by the auto-naming convention (`{instance}-ssh-key-group`), skips any still attached to another instance on the same site, and deletes the remaining unshared groups after the instance is removed. (#3832) +- Fixed BF4 DPUs receiving NICo legacy post-ready setup steps (rshim and host privilege configuration) that conflict with DPF's platform ownership and invoke operations not supported on BF4. NICo now limits its BF4 post-provisioning actions to credential rotation and the required DPU restart, leaving platform and BIOS configuration entirely to the DPF operator. (#3863) +- Fixed over-broad transaction lint exemptions in api-core that unintentionally suppressed transaction warnings across all production modules when the `test-support` feature was enabled. Exemptions are now scoped to `cfg(test)` builds and the test-support module itself, restoring full lint coverage for production code paths. See https://nvidia.github.io/infra-controller/ for the updated schema. (#3872) +- Fixed DPF power cycle handling where a power-on command was enqueued immediately after power-off before the chassis had finished processing the off request. A delay is now enforced after the power-off step before the power-on command is issued, matching the behavior of other power-cycle paths in the system. (#3906) +- Fixed a data race and panic that could occur when work was submitted to a WorkerPool concurrently with it being stopped. (#3541) +- Fixed the machine controller to route terminal boot-order job states (ScheduledWithErrors, CompletedWithErrors, Failed) into the existing HandleJobFailure path instead of continuing to poll the same persisted state indefinitely. This clears the failed job ID and allows BMC reset and power recovery to check BIOS and boot order before retrying, with bounded retry and manual-intervention behavior unchanged. (#3954) +- Moved persisted endpoint refresh orchestration from the API handler into a dedicated EndpointExplorationService, preventing stale refreshes from overwriting concurrently updated reports and sharing coordination between periodic exploration and on-demand refresh. (#3868) +- Fixed an HTTP 500 returned when retrieving attached DPU details for machines with network security policy overrides, caused by protobuf fields not surviving the Temporal workflow boundary. The REST response contract is unchanged; the API documentation now clarifies which DPU network configuration fields are exposed. (#3866) +- Made the `machine_id` field optional in the hw-health static configuration metadata, allowing hw-health to report machine metadata in environments without a NICo instance where no machine ID exists. (#4003) +- Fixed OS provisioning via an installer so that the `phone_home` callback is injected into the target OS user-data rather than the installer user-data. Previously this caused machines to report Ready or BootCompleted before the target OS had actually booted and become reachable. (#3859) +- Fixed DPU restart logging and timestamp recording to accurately reflect the actual outcome of the Redfish restart call. Failures now include the affected DPU's machine ID and the returned error, and the reboot-request timestamp is only recorded after a successful restart. (#3904) +- Fixed incorrect display of large integer values in the UI by replacing JavaScript's JSON.stringify with a Rust-based Askama filter that uses serde_json's arbitrary-precision feature. This prevents numbers exceeding JavaScript's 2^53 safe integer limit from being silently rounded when rendered. (#3985) +- Fixed DPU provisioning to continue when a host VF representor has not yet materialized, treating the missing-port condition as an expected transient failure rather than a terminal one. OVS configuration and ofport_request synchronization are still attempted normally on the PF path, and expected transient failures no longer terminate cloud-init before service restart and Scout execution. (#4029) +- Fixed hw-health discovery to properly surface fetch errors that were previously swallowed inside async closures by unwrap_or_default, ensuring discovery failures are logged rather than silently ignored. (#3987) +- Fixed the measured-boot PCR range parser to validate both range endpoints with `i16::try_from` before expansion, preventing overflowing values from wrapping into valid negative or zero indices. Invalid ranges are now rejected at parse time rather than silently producing incorrect PCR sets. (#4057) +- Fixed the log-parser's `preceded_by` constraint check, which previously allowed an empty history or a short event suffix to satisfy a longer required sequence because zip stops at the shorter iterator. A non-empty pattern and sufficient queue depth are now required before suffix comparison proceeds. (#4051) +- Fixed DPU provisioning eligibility checks to require a non-empty DPU set before evaluating BFB install support or DPF-based provisioning support, preventing a host with no attached DPUs from being incorrectly treated as eligible for aggregate provisioning. (#4055) +- Fixed boot-interface target resolution to pass the MAC address and interface ID together as a single `BootInterfaceRef::Pair`, preventing repeated mutations that could occur when a split MAC-then-ID retry path was followed on errors. Each vendor implementation selects the identifier it requires, while interfaces without a captured ID continue to use `BootInterfaceTarget::MacOnly`. (#4022) +- Fixed a bug where the `/meta-data/` index advertised an `identity` key that always returned HTTP 400 for plain GET requests, causing cloud-init's EC2/IMDS datasource to reject the entire metadata response and fail with a `KeyError: 'instance-id'`. The `identity` entry is now removed from the index while the route remains accessible to clients that include the required `Metadata: true` header. (#3905) +- Fixed `CommandExecutor` applying one extra retry beyond the configured count for mlxconfig commands, which could cause a zero-retry command to run twice contrary to its configuration. Also corrected an integer widening issue in the verbose attempt counter that could panic before reaching the maximum retry value. (#4092) +- Fixed a bug where the database connection was held open across a remote Vault network call during host UEFI credential resolution. The fix separates the database lookup of the credential version key from the subsequent secret fetch, releasing the connection before any remote I/O occurs. (#4020) +- Fixed dry-run firmware apply in libmlx making a real `mlxfwmanager` device version query, which made dry-run report output dependent on actual host state. Dry-run apply now uses the configured target as the simulated observed version; live matches, mismatches, and discovery failures retain their existing behavior. (#4114) +- Fixed a DPU reprovisioning race where a stale `Ready` or `Error` phase on a CR with a `deletionTimestamp` caused the controller to skip past the reprovisioning wait and advance prematurely. The controller now maps a set `deletionTimestamp` to `DpuPhase::Deleting` and waits for the old CR to be fully removed and the new CR to report `Ready` before proceeding. (#4125) +- Fixed a regression in secure `DiscoverMachine` that caused authentication failures for workflows such as machine validation where the connection source IP is an instance address rather than a machine interface address. The fix falls back to an instance address lookup and verifies the resolved machine ID matches the caller-provided interface ID before accepting the request; a mismatch returns permission-denied. (#4123) +- Fixed the admin CLI `show` commands for expected power shelves and expected switches producing Rust debug output for single-resource queries and appending table output after JSON when listing resources. Output is now routed through the runtime output writer and rendered exclusively as JSON or table based on the selected format, with no duplicate API requests. (#4128) +- Added missing repository metadata to all crate `Cargo.toml` files. (#4144) +- Fixed the NVLink partition monitor failing when multiple mini-racks or NMX-C domains are present in a single physical rack. The monitor previously used the cluster chassis serial number as a unique key to identify the NMX-C server endpoint, which is shared across all mini-racks in a rack; it now uses the rack ID to resolve the correct endpoint for each managed host. When managed racks are not configured or hosts lack an assigned rack ID, the partition monitor falls back to the prior behavior. (#4147) +- Fixed switch certificate setup stranding a switch in a non-retryable `Error` state when per-switch NVOS admin credentials are not yet available. The controller now checks for credentials before endpoint resolution and stays in `ConfigureCertificate::Start` with `Wait` when no usable credential source exists, allowing automatic retry once credentials are imported; existing imported credentials are preserved. (#4169) +- Changed BF4 DPU identification to use `product_name` rather than the previous identifier to correctly distinguish BF4 hardware. Additionally, DPU reboots are now skipped when no BIOS operations are performed, avoiding unnecessary restarts during provisioning. (#3978) +- Fixed `carbide_external_call_duration_milliseconds` RED metrics from generated Forge clients not appearing in the ssh-console `/metrics` export. The OpenTelemetry meter provider was not installed globally before the first generated client call; it is now installed during `MetricsState::new` initialization so all RED observations reach the exported Prometheus registry. (#4184) +- Fixed machine controller stalling indefinitely when a Redfish BIOS or boot-order job completed before the scheduling poll could observe the `Scheduled` state. Both waits now treat `Completed` as already applied: BIOS advances to `PollingBiosSetup` and boot order advances to `CheckBootOrder` without issuing a redundant `ForceRestart`. (#4183) +- Reduced the log level of a per-BMC message emitted on every Site Explorer iteration to avoid excessive log volume in large deployments. (#4149) +- Fixed hosts stalling indefinitely in `WaitingForMeasurements` when Scout failed to submit a measurement report, with no alert, no `Failed` transition, and no visibility to operators or fleet tooling. A timeout-based escalation path now transitions such hosts to `Failed` state after the measurement window expires, making the condition detectable and recoverable. (#4027) +- Fixed `route-server remove` silently returning success when no rows were deleted due to a default `source_type` mismatch between the CLI (`admin_api`) and config-file-loaded entries (`config_file`). The handler now returns `not_found` when the input is non-empty but nothing was deleted, with a message directing operators to retry with the correct `source_type`. (#4131) +- Fixed a test port allocation race in ssh-console integration tests by binding SSH and metrics listeners to ephemeral ports atomically and exposing the effective listener addresses through `SpawnHandle`. (#4142) +- Fixed nico-api aborting startup on a fresh site with DPF enabled when the site-wide BMC root credential had not yet been configured, leaving no way to set the credential through the API. The initial credential read is now best-effort when a BMC password refresh interval is configured: startup proceeds without the secret and the existing refresh task writes it as soon as the credential is available, requiring no restart. (#4167) +- Fixed intermittent deadlocks during `AdminForceDeleteMachine` caused by inconsistent topology and endpoint lock acquisition order relative to Site Explorer. Each machine topology is now locked before its explored endpoint is deleted, and the lock order is aligned with Site Explorer's ascending BMC-IP ordering. (#4015) +- DPF services `hbn` and `dts` previously inherited only the global `imagePullSecret` configuration with no mechanism to override it per service. Operators can now specify a dedicated `imagePullSecret` for each of these services independently, supporting deployments that use separate container registries or per-component credentials. (#4205) +- Health pages for switches, power shelves, racks, and NVLink domains now return HTTP 404 when the requested component does not exist, rather than returning a 200 response with an empty health report. Detail pages for non-existent racks similarly return 404 instead of rendering a blank resource view. (#4201) +- IPMI power operations now use the BMC port recorded during Redfish discovery rather than always defaulting to port 623. The discovered port is resolved before machine restart and BMC cold-reset operations, with a fallback to port 623 when discovery did not report a port. (#4135) +- Fixed a crash in the DPU agent when running in DPF mode with an extension service attached. The agent no longer panics on a missing extension service handler; it now logs a clear diagnostic, reports the service with `DPU_EXTENSION_SERVICE_ERROR` status, and continues running. (#4220) +- Pinned the `otelcol` and REST API CLI tool builds to use committed `go.mod`/`go.sum` files with `--skip-get-modules`, ensuring hermetic builds that produce reproducible binaries from the same commit. (#4129) +- Fixed a flaky metric assertion in the DPU ASN exhaustion test by isolating the ASN failure counter from unrelated parallel tests that share the process-global metric registry. (#4222) +- Fixed two regressions in SKU v5 generation that caused pre-existing machines to wedge permanently in `MatchingSku` after an upgrade. NVMe drives missing `size_mb` or `pci_path` fields (absent on hardware discovered before those fields were introduced) are now included in generation with whatever fields are available, allowing machines to self-heal on the next hardware re-enumeration. A secondary fix prevents `diff_storage_by_model` from silently dropping duplicate drive models when comparing against v4 expected SKUs. (#4207) +- Services that attempt to bind on the default IPv6 address now fall back to IPv4 when the IPv6 bind fails, preventing startup failures on hosts where IPv6 is unavailable or disabled. (#4179) +- Added SPIFFE workload identity authorization to the Flow gRPC service so that a valid mTLS certificate alone no longer grants access to any workload holding a certificate from a trusted CA. Flow now extracts the caller's SPIFFE ID from the verified client certificate and checks it against an explicit allowlist before admitting unary or streaming RPCs. A recovery interceptor was also added to prevent panics from terminating the gRPC server. (#4140) +- Fixed a bug where the `HostUpdateInProgress` health alert was never cleared from DPF-ingested hosts after an automatic DPU firmware update completed. DPF hosts are now processed through a dedicated completion path that compares the installed BFB against the expected version from the `DPUDeployment`, mirroring the same split used during update detection. (#4236) +- Updated `quinn-proto`, `cmov`, `serde_with`, and `russh` dependency versions to resolve outstanding Dependabot security alerts. (#4241) +- Changed the convention for clearing a stored BMC IP address on an `ExpectedMachine`: submitting an empty string (`""`) now explicitly clears the field, while omitting the field or sending JSON `null` leaves the existing value unchanged. Batch BMC IP updates apply a scoped bulk operation so rows that omit the field retain their current value. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4251) +- Fixed a race condition in the REST-to-Core Temporal proxy workflow where the Core workflow could execute a non-idempotent mutation after the REST caller had already returned HTTP 504. The Core proxy workflow timeout is now set to 45 seconds, below the 50-second REST caller timeout, ensuring the workflow terminates before the caller gives up. (#3584) +- Added validation that rejects duplicate `ExpectedHostNic` entries where the same MAC address is assigned conflicting roles, preventing inconsistent DHCP and Site Explorer behavior. Interfaces configured with explicit `Fixed` allocation or DPU roles now require `fixed_ip` to fall within a configured managed prefix, and existing exact reservations must belong to the same segment. (#4255) +- Removed a stale `package.json` from the web frontend directory that was no longer needed after the migration from SCSS to plain CSS, eliminating spurious Dependabot alerts for unused Node.js dependencies. (#4243) +- Retained a database column that was scheduled for removal in order to maintain schema compatibility during rolling deployments where API pods of different versions may run concurrently. A type enum naming convention inconsistency was also corrected. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4214) +- Updated the DPF Helm build to use the `CARBIDE_BUILD_HELM_VERSION` value computed by CI directly, rather than re-deriving it independently. (#4233) +- Fixed BF4 DPU identification under DPF to use the product name rather than the part number, correcting detection for BF4 Astra hardware. (#4287) +- Updated `bmc-mock` Redfish resource paths for BF4 to match the layout introduced in BF4 firmware version BF4-26.04-10. (#4260) +- Fixed transient `AddrInUse` failures when binding ephemeral SSH console and metrics listeners under concurrent load. Port-zero listeners now retry on `AddrInUse` up to a bounded limit; explicitly configured ports and all other bind errors continue to fail immediately. (#4265) +- The Core API now returns an explicit `AlreadyExists` error when a caller attempts to create a SKU with an ID that is already registered, rather than surfacing a raw database constraint violation. (#4242) +- Fixed Kubernetes deployment update strategies by setting `maxUnavailable: 100%` for all NICo Services, ensuring rolling updates complete without blocking on pod availability thresholds. Also corrected configport handling in the DTS component. (#4294) +- Fixed a bug in machine inventory processing where network interfaces with no IP addresses were silently dropped due to a nil-versus-empty-array mismatch on the database write path. Empty address lists are now stored as empty arrays, preserving all addressless interfaces throughout the inventory pipeline. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4137) +- Fixed ServiceMonitors that hard-coded the `nico-system` namespace in their selector configuration, which prevented Prometheus from scraping metrics when NICo was deployed to a custom namespace. Each affected chart now passes its resolved namespace to the shared ServiceMonitor helper. (#4306) +- Fixed an issue where extension services attached to DPF-managed instances could prevent those instances from reaching `RUNNING` state and leave them stuck during termination waiting for a `TERMINATED` status that was never reported. Extension services are now blocked from being attached to DPF-managed instances, and services that were attached before DPF reprovisioning are reported as `TERMINATED` during cleanup so instance lifecycle can proceed normally. (#4303) +- Fixed an intermittent issue where `WorkLock` release commands could be silently discarded when the bounded manager command queue was full, leaving database lock rows held until keepalive expiry and potentially stalling `SiteExplorer` long enough to trigger machine wait timeouts. WorkLock releases now use an unbounded FIFO queue separate from semaphore-gated commands, ensuring releases are never dropped regardless of command queue pressure. (#4266) +- Fixed incorrect agent registration caused by DHCP being active on non-boot network interfaces before the DPU agent starts. The boot NIC is now identified from the kernel command line `mac=` parameter, and DHCP is disabled on all other interfaces prior to agent startup, preventing onboard NICs that appear earlier in the routing table from being used for registration. (#4120) +- Fixed firmware upload metrics where a BMC-declined multipart upload that successfully fell back to `HttpPushUri` was incorrectly recorded as both a multipart error and an HTTP push success. A declined multipart route is now distinguished from a genuine multipart failure, so `carbide_preingestion_firmware_upload_total` counters accurately reflect true upload outcomes. (#4322) +- Added a power-aware NVOS lifecycle to the machine-a-tron switch simulator, enabling simulated NVOS switches to perform DHCP on power-on, register mock bootstrap credentials, and advance through the switch controller to `ready` state without physical hardware. (#4333) +- Fixed spurious error log entries produced when site-explorer attempted to generate a `MachineId` for switches, which have their own `SwitchId` generation path and may not expose a system serial number. Switch enrichment and `SwitchId` generation are preserved. (#4337) +- Fixed a bug where `create_initial_networks` stopped seeding additional configured network segments once reverse-DNS zones were present in the `domains` table, causing new segments to be silently skipped with an ambiguous-domain warning. Domain selection during initial network seeding is now restricted to forward domains only, preserving correct behavior regardless of how many reverse zones exist. (#4342) +- Fixed multiple REST API v2.0 inconsistencies across behavior, OpenAPI definitions, generated SDKs, CLI, and MCP guidance. Machine power control is now correctly restricted to Provider Admins, the BMC credential response contract is corrected, DPU reprovisioning prerequisites and modes are documented, and published `nicocli` action names and MCP behavior are updated to match the current implementation. (#3321) +- Fixed a missing FMDS instance metadata gateway address (`169.254.169.253/30`) on DPU hosts operating in FNN mode with an L3 physical tenant interface. The gateway address is now rendered in the L3 interface IP block in addition to the existing L2 SVI block, ensuring correct callhome routing in FNN deployments. (#4338) +- Fixed an issue where network segments added to `site-config` after a site's initial API startup were silently ignored on every subsequent API restart. Network creation decisions are now made per-segment during drift reconciliation, ensuring any newly configured segments are created on the next API restart. (#4387) +- Fixed a duplicate SQLx migration version that caused fresh database initialization to fail when the second migration with the same primary-key version was applied. The BMC suppression migration was reassigned to a unique version, and a regression test was added to detect duplicate versions across all legacy, squash, and post-squash migration sets. (#4428) +- Fixed machine-a-tron test scenarios where a retrying boot action could remain queued after a power state change, blocking subsequent power-off cleanup and power-cycle timers. Boot and agent actions tied to the previous power cycle are now invalidated when the machine powers off or cycles, while BMC-scoped setup, BMC DHCP, and power-off cleanup actions remain queued. (#4430) +- Fixed a database migration conflict where two separate fixes for a duplicate migration version collided on `main`, removing the original `20260722120000` checksum that existing databases had already recorded. The loopback preservation migration is restored to its original `20260722120000` timestamp with byte-for-byte identical SQL, preserving upgrade compatibility for deployed databases. (#4432) +- Fixed incorrect classification of statically allocated NVOS data interface addresses as BMC IPs during IP address lookups by examining interface type alongside allocation type. The CLI `ip search` command also now displays the associated switch when the queried address belongs to a switch interface. See https://nvidia.github.io/infra-controller/ for the updated schema. (#4395) +- Fixed a race condition in the machine controller where the host power-on sequence could begin before the BMC had fully applied the `ForceOff` command. A dedicated `WaitingForPlatformPowerOff` phase was introduced to persist the power-off wait state, ensuring the observed power-off is confirmed before transitioning to the power-on phase. This makes the power cycle sequence restart-safe if the controller process exits between the Redfish request and state commit. (#4454) +- Fixed site-explorer NIC discovery for systems such as Lenovo XCC that do not populate `Systems/.../EthernetInterfaces` with usable MAC addresses. The explorer now falls back to adapter-port MACs discovered via `Chassis/.../NetworkAdapters/.../Ports` when no MAC-bearing System EthernetInterface is present, allowing zero-DPU predicted interfaces required for DHCP and PXE boot to be created correctly. Normal System EthernetInterface inventory remains preferred, and DPU, switch, and power-shelf discovery paths are unaffected. (#4439) + +### Security + +- Removed the Grype vulnerability scan from per-PR CI pipelines to eliminate a multi-minute bottleneck; container image vulnerability scanning continues on scheduled cadences where findings are more actionable. (#3669) +- Added CSRF protection to the admin UI using the `tower-http` CSRF middleware. Requests bearing a `Sec-Fetch-Site` header (sent by all modern browsers) are now required to originate from the same origin, preventing a logged-in admin session from being exploited by a cross-site form submission. Non-browser clients such as curl scripts are unaffected, as they do not send the `Sec-Fetch-Site` header. (#3798) +- Added counters for Transit KMS token maintenance failures, converting background lookup and renewal warning paths into trendable metrics via `carbide_kms_token_maintenance_failures_total` with a bounded `stage={lookup,renew}` label. Vault errors remain log-only; token, mount, and key identity are excluded from the metric. Existing retry delays, cancellation, and renewal scheduling are unchanged. (#4083) From 54dcacfa2ec53be456606400d9086856cafdec0a Mon Sep 17 00:00:00 2001 From: Abhishek Varshney Date: Wed, 5 Aug 2026 22:35:30 +0530 Subject: [PATCH 02/26] fix: Validate that both DPF and VMAAS are not enabled at the same time. (backport #4477) (#4592) Backport of #4477 to `release/v2.1`. Validate that both DPF and VMAAS are not enabled at the same time. ## Related issues ## Type of Change - [ ] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [x] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [ ] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [x] No testing required (docs, internal refactor, etc.) ## Additional Notes Backport of #4477. Signed-off-by: Abhishek Varshney Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- crates/api-core/src/setup.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/api-core/src/setup.rs b/crates/api-core/src/setup.rs index 94379733c3..c11164c7b2 100644 --- a/crates/api-core/src/setup.rs +++ b/crates/api-core/src/setup.rs @@ -203,6 +203,14 @@ pub(crate) async fn start_runtime( cancel_token: CancellationToken, ready_channel: Sender<()>, ) -> eyre::Result<()> { + eyre::ensure!( + !matches!( + (carbide_config.dpf.enabled, &carbide_config.vmaas_config), + (true, Some(_)) + ), + "cannot enable both VMaaS and DPF; disable one in the configuration" + ); + let shared_redfish_pool = create_redfish_pool(&carbide_config, credential_manager.clone())?; let shared_nv_redfish_pool = carbide_redfish::nv_redfish::new_pool(carbide_config.site_explorer.bmc_proxy.clone()); From a152fc20f80e6c3eea39c33d7227596ae3a53bcb Mon Sep 17 00:00:00 2001 From: Patrice Breton Date: Wed, 5 Aug 2026 10:53:49 -0700 Subject: [PATCH 03/26] patch(v2.1): allow tenants to use provider templated OSes (#4595) ## What changed - backport PR #4489 to `release/v2.1` - allow tenants to select provider-owned templated iPXE Operating Systems when creating, updating, or batch-creating Instances - keep tenant-owned Operating Systems private to their owning tenant - retain the requirement that the provider-owned templated OS has a `Synced` association with the Instance site - centralize the access rule in `OperatingSystem.IsTenantUsable` ## Root cause Provider-managed templated Operating Systems intentionally have no `tenant_id`. The Instance OS ownership checks required every selected OS to be tenant-owned and attempted to use that missing tenant ID, even though provider-managed definitions are exposed to tenants at associated sites. ## Impact Tenants using the v2.1 release can select provider-managed templated iPXE definitions synchronized to their Instance site. Cross-tenant definitions and provider definitions unavailable at that site remain rejected. ## Validation - `git diff --check upstream/release/v2.1...HEAD` - `go test -p 1 ./db/pkg/db/model ./api/pkg/api/handler -count=1` Backport of #4489. --------- Signed-off-by: Patrice Breton --- rest-api/api/pkg/api/handler/instance.go | 18 +++--- rest-api/api/pkg/api/handler/instance_test.go | 60 +++++++++++++++++++ rest-api/api/pkg/api/handler/instancebatch.go | 7 ++- rest-api/db/pkg/db/model/operatingsystem.go | 12 ++++ .../db/pkg/db/model/operatingsystem_test.go | 56 +++++++++++++++++ 5 files changed, 142 insertions(+), 11 deletions(-) diff --git a/rest-api/api/pkg/api/handler/instance.go b/rest-api/api/pkg/api/handler/instance.go index c741c285af..a7f351cb54 100644 --- a/rest-api/api/pkg/api/handler/instance.go +++ b/rest-api/api/pkg/api/handler/instance.go @@ -182,9 +182,9 @@ func NewCreateInstanceHandler(dbSession *cdb.Session, tc temporalClient.Client, // validateTemplatedIpxeOsForSite guards the Templated iPXE Operating System // selection paths (Instance create / update / batch-create) before the OS ID is -// sent to Core. Caller authorization and tenant/OS ownership are already enforced +// sent to Core. Caller authorization and tenant/OS access are already enforced // by the handlers (ValidateOrgMembership / ValidateUserRoles) and the per-request -// ownership check, so this enforces the site-availability contract specific to +// usability check, so this enforces the site-availability contract specific to // templated OSes: the OS definition must be synchronized to the Instance's Site // (a Synced OperatingSystemSiteAssociation) so the Site can render the template // at provisioning time. @@ -281,9 +281,10 @@ func (cih CreateInstanceHandler) buildInstanceCreateRequestOsConfig(c echo.Conte return c.Str("OperatingSystem ID", os.ID.String()) }) - // Confirm ownership between tenant and OS. - if os.TenantID.String() != apiRequest.TenantID { - logger.Error().Msg("OperatingSystem in request is not owned by tenant") + // Confirm the Tenant can use the OS. Provider-owned Templated iPXE OSes are + // shared through synchronized Site associations validated below. + if !os.IsTenantUsable(apiRequest.TenantID) { + logger.Error().Msg("OperatingSystem in request is not usable by tenant") return nil, nil, cutil.NewAPIError(http.StatusBadRequest, "OperatingSystem specified in request is not owned by Tenant", nil) } @@ -2232,9 +2233,10 @@ func (uih UpdateInstanceHandler) buildInstanceUpdateRequestOsConfig(c echo.Conte return c.Str("OperatingSystem ID", os.ID.String()) }) - // Confirm ownership between tenant and OS. - if os.TenantID.String() != instance.Tenant.ID.String() { - logger.Error().Msg("OperatingSystem in request is not owned by tenant") + // Confirm the Tenant can use the OS. Provider-owned Templated iPXE OSes + // are shared through synchronized Site associations validated below. + if !os.IsTenantUsable(instance.Tenant.ID.String()) { + logger.Error().Msg("OperatingSystem in request is not usable by tenant") return nil, nil, cutil.NewAPIError(http.StatusBadRequest, "Operating system specified in request is not owned by Tenant", nil) } diff --git a/rest-api/api/pkg/api/handler/instance_test.go b/rest-api/api/pkg/api/handler/instance_test.go index 69acbebe64..eeb5e4efa1 100644 --- a/rest-api/api/pkg/api/handler/instance_test.go +++ b/rest-api/api/pkg/api/handler/instance_test.go @@ -10618,6 +10618,20 @@ func TestBuildInstanceOsConfig_TemplatedIPXE(t *testing.T) { osSynced := buildOS("tmpl-os-instance-os-synced") testInstanceBuildOperatingSystemSiteAssociation(t, dbSession, site.ID, osSynced.ID) + providerOS := &cdbm.OperatingSystem{ + ID: uuid.New(), + Name: "tmpl-os-instance-provider-os", + Org: ip.Org, + InfrastructureProviderID: &ip.ID, + Type: cdbm.OperatingSystemTypeTemplatedIPXE, + IsActive: true, + Status: cdbm.OperatingSystemStatusReady, + CreatedBy: user.ID, + } + _, err := dbSession.DB.NewInsert().Model(providerOS).Exec(context.Background()) + require.NoError(t, err) + testInstanceBuildOperatingSystemSiteAssociation(t, dbSession, site.ID, providerOS.ID) + t.Run("create", func(t *testing.T) { ec := newTemplatedOsEchoContext(t) h := CreateInstanceHandler{dbSession: dbSession, cfg: cfg} @@ -10669,6 +10683,52 @@ func TestBuildInstanceOsConfig_TemplatedIPXE(t *testing.T) { assertTemplatedOsConfig(t, osConfig, osSynced.ID) }) + providerCases := []struct { + name string + build func() (*corev1.InstanceOperatingSystemConfig, *uuid.UUID, *cutil.APIError) + }{ + { + name: "create allows provider-owned OS", + build: func() (*corev1.InstanceOperatingSystemConfig, *uuid.UUID, *cutil.APIError) { + h := CreateInstanceHandler{dbSession: dbSession, cfg: cfg} + req := &model.APIInstanceCreateRequest{ + TenantID: tenant.ID.String(), + OperatingSystemID: cutil.GetPtr(providerOS.ID.String()), + } + return h.buildInstanceCreateRequestOsConfig(newTemplatedOsEchoContext(t), &logger, req, site) + }, + }, + { + name: "update allows provider-owned OS", + build: func() (*corev1.InstanceOperatingSystemConfig, *uuid.UUID, *cutil.APIError) { + h := UpdateInstanceHandler{dbSession: dbSession, cfg: cfg} + instance := &cdbm.Instance{ID: uuid.New(), TenantID: tenant.ID, Tenant: tenant} + req := &model.APIInstanceUpdateRequest{OperatingSystemID: cutil.GetPtr(providerOS.ID.String())} + return h.buildInstanceUpdateRequestOsConfig(newTemplatedOsEchoContext(t), &logger, req, instance, site) + }, + }, + { + name: "batch create allows provider-owned OS", + build: func() (*corev1.InstanceOperatingSystemConfig, *uuid.UUID, *cutil.APIError) { + h := BatchCreateInstanceHandler{dbSession: dbSession, cfg: cfg} + req := &model.APIBatchInstanceCreateRequest{ + TenantID: tenant.ID.String(), + OperatingSystemID: cutil.GetPtr(providerOS.ID.String()), + } + return h.buildBatchInstanceCreateRequestOsConfig(newTemplatedOsEchoContext(t), &logger, req, site) + }, + }, + } + for _, tc := range providerCases { + t.Run(tc.name, func(t *testing.T) { + osConfig, osID, apiErr := tc.build() + require.Nil(t, apiErr) + require.NotNil(t, osID) + assert.Equal(t, providerOS.ID, *osID) + assertTemplatedOsConfig(t, osConfig, providerOS.ID) + }) + } + // The following cases exercise the shared validator through the create path; // the same validator gates the update and batch paths. diff --git a/rest-api/api/pkg/api/handler/instancebatch.go b/rest-api/api/pkg/api/handler/instancebatch.go index c913c26c4b..fab4a051c1 100644 --- a/rest-api/api/pkg/api/handler/instancebatch.go +++ b/rest-api/api/pkg/api/handler/instancebatch.go @@ -123,9 +123,10 @@ func (bcih BatchCreateInstanceHandler) buildBatchInstanceCreateRequestOsConfig(c return c.Str("OperatingSystem ID", os.ID.String()) }) - // Confirm ownership between tenant and OS. - if os.TenantID.String() != apiRequest.TenantID { - logger.Error().Msg("OperatingSystem in request is not owned by tenant") + // Confirm the Tenant can use the OS. Provider-owned Templated iPXE OSes are + // shared through synchronized Site associations validated below. + if !os.IsTenantUsable(apiRequest.TenantID) { + logger.Error().Msg("OperatingSystem in request is not usable by tenant") return nil, nil, cutil.NewAPIError(http.StatusBadRequest, "OperatingSystem specified in request is not owned by Tenant", nil) } diff --git a/rest-api/db/pkg/db/model/operatingsystem.go b/rest-api/db/pkg/db/model/operatingsystem.go index 28e0b061a3..377c5341cd 100644 --- a/rest-api/db/pkg/db/model/operatingsystem.go +++ b/rest-api/db/pkg/db/model/operatingsystem.go @@ -257,6 +257,18 @@ type OperatingSystem struct { CreatedBy uuid.UUID `bun:"type:uuid,notnull"` } +// IsTenantUsable reports whether the Operating System can be used by the +// specified Tenant. Tenant-owned definitions are private to their owner. +// Provider-owned Templated iPXE definitions are shared through synchronized +// Site associations, which callers validate separately. +func (os *OperatingSystem) IsTenantUsable(tenantID string) bool { + if os.TenantID != nil { + return os.TenantID.String() == tenantID + } + + return os.InfrastructureProviderID != nil && os.Type == OperatingSystemTypeTemplatedIPXE +} + // GetSiteID returns the OperatingSystem ID to use when communicating // with the Site: ControllerOperatingSystemID when present, otherwise // the OS's own ID. The Site treats both as opaque identifiers. diff --git a/rest-api/db/pkg/db/model/operatingsystem_test.go b/rest-api/db/pkg/db/model/operatingsystem_test.go index 2011524586..fb41d4a9e4 100644 --- a/rest-api/db/pkg/db/model/operatingsystem_test.go +++ b/rest-api/db/pkg/db/model/operatingsystem_test.go @@ -39,6 +39,62 @@ func TestOperatingSystem_GetSiteID(t *testing.T) { }) } +func TestOperatingSystem_IsTenantUsable(t *testing.T) { + tenantID := uuid.New() + otherTenantID := uuid.New() + providerID := uuid.New() + + tests := []struct { + name string + os OperatingSystem + tenantID string + want bool + }{ + { + name: "allows tenant-owned OS for owner", + os: OperatingSystem{TenantID: &tenantID}, + tenantID: tenantID.String(), + want: true, + }, + { + name: "rejects tenant-owned OS for another tenant", + os: OperatingSystem{TenantID: &tenantID}, + tenantID: otherTenantID.String(), + want: false, + }, + { + name: "allows provider-owned templated iPXE OS", + os: OperatingSystem{ + InfrastructureProviderID: &providerID, + Type: OperatingSystemTypeTemplatedIPXE, + }, + tenantID: tenantID.String(), + want: true, + }, + { + name: "rejects provider-owned raw iPXE OS", + os: OperatingSystem{ + InfrastructureProviderID: &providerID, + Type: OperatingSystemTypeIPXE, + }, + tenantID: tenantID.String(), + want: false, + }, + { + name: "rejects OS without an owner", + os: OperatingSystem{Type: OperatingSystemTypeTemplatedIPXE}, + tenantID: tenantID.String(), + want: false, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.want, tc.os.IsTenantUsable(tc.tenantID)) + }) + } +} + func TestOperatingSystem_ToImageAttributesProto(t *testing.T) { id := uuid.New() desc := "primary" From 85c95bf3f5f9a1a40bb50902b914653d4511a8e2 Mon Sep 17 00:00:00 2001 From: nv-dmendoza <117955115+nv-dmendoza@users.noreply.github.com> Date: Wed, 5 Aug 2026 16:33:11 -0700 Subject: [PATCH 04/26] patch(2.1): fix lint police simulated merge base branch used (#4620) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backports #4601 The lint police job was failing on release branch PRs: https://github.com/NVIDIA/infra-controller/actions/runs/31021360041/job/92359688163 The `Build pull request merge result` step was hardcoded to always merge against `origin/main`: ```yaml git fetch --no-tags origin main:refs/remotes/origin/main git merge --no-commit --no-ff origin/main ``` This fails when a PR targets a release branch because the simulated merge is against the wrong base. `GITHUB_BASE_REF` can't be used here since the workflow triggers on `push` events (to `pull-request/N` branches), not `pull_request` events — so that variable is never populated. Instead, the PR number is extracted from `GITHUB_REF_NAME` and used to query the GitHub API for the actual target branch: ```yaml # calculate target branch PR_NUMBER="${GITHUB_REF_NAME##pull-request/}" TARGET=$(curl -sf \ -H "Authorization: Bearer $GITHUB_TOKEN" \ -H "Accept: application/vnd.github+json" \ "https://api.github.com/repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER" \ | jq -r '.base.ref') # simulate merge git fetch --no-tags origin "${TARGET}:refs/remotes/origin/${TARGET}" git merge --no-commit --no-ff "origin/${TARGET}" ``` This makes the simulated merge match the branch the PR will actually land on. ## Related issues ## Type of Change - [ ] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [x] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [ ] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) ## Additional Notes --- .github/workflows/ci.yaml | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index bf8cd2e33f..fbb23ba4a0 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -1458,12 +1458,20 @@ jobs: persist-credentials: false - name: Build pull request merge result + env: + GITHUB_TOKEN: ${{ github.token }} run: | git config --global --add safe.directory "$GITHUB_WORKSPACE" - git fetch --no-tags origin main:refs/remotes/origin/main + PR_NUMBER="${GITHUB_REF_NAME##pull-request/}" + TARGET=$(curl -sf \ + -H "Authorization: Bearer $GITHUB_TOKEN" \ + -H "Accept: application/vnd.github+json" \ + "https://api.github.com/repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER" \ + | jq -r '.base.ref') + git fetch --no-tags origin "${TARGET}:refs/remotes/origin/${TARGET}" git -c user.name="CI merge validation" \ -c user.email=ci@example.invalid \ - merge --no-commit --no-ff origin/main + merge --no-commit --no-ff "origin/${TARGET}" - name: Validate Cargo metadata run: cargo metadata --locked --no-deps --format-version 1 >/dev/null From 15bb74f092f2e5642d1346039bcd449926bf197d Mon Sep 17 00:00:00 2001 From: Tareque Hossain Date: Thu, 6 Aug 2026 16:28:32 -0700 Subject: [PATCH 05/26] patch(v2.1): Prevent BuildKit layer export to shared Actions cache (#4677) Pipelines for this branch has ungated BuildKit cache export, which is evicting crucial cache used in CI optimizations released this week. For example `v2.1.0-smcgb300`/`v2.1.0-smcgb300-1` pushed `32GB` into the `50GB` cache shared with main, evicting/reducing main's sccache entries from `16GB` to `5GB`. This PR disables BuildKit caches for `release/v2.1`, avoiding future evictions from this branch. ## Type of Change - [x] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [x] No testing required (docs, internal refactor, etc.) --- .github/workflows/docker-build.yml | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/.github/workflows/docker-build.yml b/.github/workflows/docker-build.yml index aebbfd7122..63d00b9b9c 100644 --- a/.github/workflows/docker-build.yml +++ b/.github/workflows/docker-build.yml @@ -235,7 +235,16 @@ jobs: tags: ${{ steps.tag_list.outputs.tags }} build-args: ${{ steps.parse-args.outputs.build_args }} cache-from: ${{ inputs.cache && 'type=gha' || '' }} - cache-to: ${{ inputs.cache && inputs.push && 'type=gha,mode=max' || '' }} + # Never exported from this branch. The Actions cache is a single 50 GB + # pool shared with main and every pull request, and its entries are + # scoped per ref: layers pushed from a release branch or a release tag + # can only be restored by a later run on that same ref, and a tag is + # built exactly once. So an export here buys this branch close to + # nothing while costing the pool real space -- the v2.1.0-smcgb300-2 tag + # run pushed 32 GB of layers in, which evicted main's sccache entries + # from 16 GB down to 5 GB and left main's Rust builds compiling from + # scratch. cache-from is kept because a lookup that misses is cheap. + cache-to: '' - name: Login to target registry if: ${{ inputs.push && !contains(inputs.platforms, ',') && github.repository != 'NVIDIA/infra-controller' }} From 740eceb9f04b5613215693325684e72be938096e Mon Sep 17 00:00:00 2001 From: behroozrafii Date: Thu, 6 Aug 2026 16:46:19 -0700 Subject: [PATCH 06/26] patch(v2.1): allow site-agent to call REST-proxied admin operations (#4676) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Backport of #4639, which has already been reviewed and merged into `main`, to `release/v2.1`. The 2.1 release has the same REST-to-Core proxy paths and missing SiteAgent RBAC permissions. This patch applies the same one-file change, allowing SiteAgent to call `AdminPowerControl` and `TriggerDpuReprovisioning` with the same regression coverage. ## Related issues - Backport of merged PR #4639 - Related to #4597 ## Type of Change - [ ] Add - New feature or capability - [ ] Change - Changes in existing functionality - [x] Fix - Bug fixes - [ ] Remove - Removed features or deprecated functionality - [ ] Internal - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] This PR contains breaking changes ## Testing - [x] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) Same regression coverage as #4639: assertions for both methods using the literal `elektra-site-agent` SPIFFE service identifier, plus negative assertions confirming an unrelated service (`nico-dns`) is still denied. Verified against `release/v2.1` in a Linux container: - `cargo test --locked -p carbide-api-core --lib auth::internal_rbac_rules` - 2 passed; 0 failed; 0 ignored; 0 measured; 1537 filtered out - `cargo make clippy-flow` - `cargo make carbide-lints` - `cargo make lint-error-messages` - scanned 2875 files; all `C-GOOD-ERR` - `cargo make check-format-nightly` - `cargo make check-event-names` - checked 194 `event_name` declarations - `cargo make check-workspace-deps` - `cargo make check-metric-docs` - 123 counters/histograms documented - `cargo make check-licenses` - licenses OK - `cargo make check-bans` - bans OK; duplicate-crate warnings were non-fatal The aggregate `cargo make pre-commit-verify-workspace` task was not run because the available Docker image does not include Go or Buf, which are required by `generate-rest-core-proto`. The change does not modify proto sources or generated output. All nine remaining gate tasks listed above were run individually and passed. ## Additional Notes **Scope.** This is a targeted backport. It changes only the two RBAC entries confirmed by #4597; no other permissions are modified. See #4639 for the full audit of REST-proxied methods. **Known limitation.** This allows REST-proxied admin operations to reach Core as the site agent. It does not make Core distinguish between “a Provider admin requested this through REST” and “the site agent initiated it directly”—the original Provider-admin identity is lost at the `ExecuteCoreGRPC` proxy boundary. Propagating it would be a cross-cutting change and is out of scope. Signed-off-by: Behrooz Rafii --- .../api-core/src/auth/internal_rbac_rules.rs | 25 +++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/crates/api-core/src/auth/internal_rbac_rules.rs b/crates/api-core/src/auth/internal_rbac_rules.rs index 31913fcdaa..de9ccf2545 100644 --- a/crates/api-core/src/auth/internal_rbac_rules.rs +++ b/crates/api-core/src/auth/internal_rbac_rules.rs @@ -300,7 +300,7 @@ impl InternalRBACRules { x.perm("AdminGrowResourcePool", vec![ForgeAdminCLI]); x.perm("SetMaintenance", vec![ForgeAdminCLI, SiteAgent, Flow]); x.perm("SetDynamicConfig", vec![ForgeAdminCLI, Machineatron]); - x.perm("TriggerDpuReprovisioning", vec![ForgeAdminCLI]); + x.perm("TriggerDpuReprovisioning", vec![ForgeAdminCLI, SiteAgent]); x.perm("TriggerHostReprovisioning", vec![ForgeAdminCLI, Flow]); x.perm("ListDpuWaitingForReprovisioning", vec![ForgeAdminCLI]); x.perm("MarkManualFirmwareUpgradeComplete", vec![ForgeAdminCLI]); @@ -516,7 +516,7 @@ impl InternalRBACRules { ); x.perm("HeartbeatMachineValidationRun", vec![Scout, SiteAgent]); x.perm("AdminBmcReset", vec![ForgeAdminCLI]); - x.perm("AdminPowerControl", vec![ForgeAdminCLI, Flow]); + x.perm("AdminPowerControl", vec![ForgeAdminCLI, SiteAgent, Flow]); x.perm("DisableSecureBoot", vec![ForgeAdminCLI]); x.perm("MachineSetup", vec![ForgeAdminCLI]); x.perm("SetDpuFirstBootOrder", vec![ForgeAdminCLI]); @@ -1134,6 +1134,27 @@ mod rbac_rule_tests { "elektra-site-agent".to_string() )] )); + + // REST admin operations proxy to Core as the site agent (issue #4597). + for method in ["AdminPowerControl", "TriggerDpuReprovisioning"] { + assert!( + InternalRBACRules::allowed_from_static( + method, + &[Principal::SpiffeServiceIdentifier( + "elektra-site-agent".to_string() + )] + ), + "{method} should allow the site agent" + ); + assert!( + !InternalRBACRules::allowed_from_static( + method, + &[Principal::SpiffeServiceIdentifier("nico-dns".to_string())] + ), + "{method} should reject unrelated services" + ); + } + assert!(InternalRBACRules::allowed_from_static( "FindNetworkSegmentsByIds", &[ From 32e25010f44e2a6fc72bf250110316110c382669 Mon Sep 17 00:00:00 2001 From: Hua-Wei Chen Date: Fri, 7 Aug 2026 07:48:13 +0800 Subject: [PATCH 07/26] backport: minimal SMC GB300 support (#4121) to release/v2.1 (#4645) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backport of SMC GB300 support onto `release/v2.1` to build a v2.1 image for onboarding the GB300 trays. ## Commits 1. **#4121** (`bb7ff72f`) — minimal SMC GB300 support: libredfish v0.46.2→v0.46.3 (OpenBMC vendor routing, libredfish #111) + bmc-explorer GB300 handling. Cherry-picked from `main` (`556bdd89`). 2. **`4354b769`** — include ARM host boot artifacts in BFB image (fork `41a957228`): packages `scout.efi` for aarch64 so Grace/ARM GB300 can HTTP-boot scout. 3. **`11f862a1`** — prefer boot NIC during Scout startup (fork `8d7ae4c80`): adds `forge-scout-network.sh` boot-NIC selection. 4. **`32d4ae24`** — wait for boot NIC before filtering Scout DHCP (fork `241af6089`). Commits 2–4 are cherry-picked from `martinraumann/smcgb300/v2.0-controller-backport` (never upstreamed to main; only #4121 was). They apply cleanly onto v2.1. ## Intentionally NOT included (already in v2.1) - fork `02c0f6ffd` "use DHCP link address for prediction promotion" + test `4403a8256` — **redundant**: v2.1 `crates/api-core/src/dhcp/discover.rs` already selects `link_address` over the relay/giaddr (`address_to_use_for_dhcp = link_address.as_ref().unwrap_or(&relay_address)`). - `#4145` setup-status correlation, `#3454` host-boot-interface convergence — already on `release/v2.1`. cc @martinraumann — please sanity-check the v2.0→v2.1 adaptation of commits 2–4 (they applied clean, but they're your patches). --------- Signed-off-by: Krish Dandiwala Co-authored-by: Krish Dandiwala Co-authored-by: Martin Raumann Co-authored-by: firmus-rajmohanr --- Cargo.lock | 2 +- Cargo.toml | 2 +- crates/bmc-explorer/src/hw/mod.rs | 1 + .../bmc-explorer/src/hw/supermicro_gb300.rs | 29 +++++++ crates/bmc-explorer/src/lib.rs | 38 +++++++-- .../integration/supermicro_gb300_explore.rs | 22 +++++ .../bmc-mock/src/hw/supermicro_gb300_nvl.rs | 26 +++--- pxe/Makefile.toml | 9 +- pxe/common_files/forge-scout-network.sh | 85 +++++++++++++------ pxe/common_files/scout-loader-rclocal | 17 ++++ .../scout-loader-aarch64/mkosi.conf | 1 + .../scout-loader-x86_64/mkosi.conf | 1 + .../scout-oss-aarch64/mkosi.conf | 1 + .../scout-oss-x86_64/mkosi.conf | 1 + 14 files changed, 185 insertions(+), 50 deletions(-) create mode 100644 crates/bmc-explorer/src/hw/supermicro_gb300.rs diff --git a/Cargo.lock b/Cargo.lock index 41f838fef6..681be9a661 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6840,7 +6840,7 @@ dependencies = [ [[package]] name = "libredfish" version = "0.0.0" -source = "git+https://github.com/NVIDIA/libredfish.git?tag=v0.46.2#5bf822b5e7814df67e2b9a8f98f41fb96dea0a3b" +source = "git+https://github.com/NVIDIA/libredfish.git?tag=v0.46.3#b199e7bebeb8238fe1440f110d06affba5b6b799" dependencies = [ "chrono", "clap", diff --git a/Cargo.toml b/Cargo.toml index b642e1b345..6eaa86c4b1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,7 +27,7 @@ repository = "https://github.com/NVIDIA/infra-controller" [workspace.dependencies] clap = { version = "4", features = ["derive", "env"] } -libredfish = { git = "https://github.com/NVIDIA/libredfish.git", tag = "v0.46.2" } +libredfish = { git = "https://github.com/NVIDIA/libredfish.git", tag = "v0.46.3" } librms = { git = "https://github.com/NVIDIA/nv-rms-client.git", tag = "v0.10.0" } ansi-to-html = "0.2.2" diff --git a/crates/bmc-explorer/src/hw/mod.rs b/crates/bmc-explorer/src/hw/mod.rs index 2105cb7a7c..08f75db3ff 100644 --- a/crates/bmc-explorer/src/hw/mod.rs +++ b/crates/bmc-explorer/src/hw/mod.rs @@ -27,6 +27,7 @@ pub mod lenovo; pub mod lenovo_ami; pub mod lenovo_gb300; pub mod supermicro; +pub mod supermicro_gb300; pub mod vera_rubin; pub mod viking; diff --git a/crates/bmc-explorer/src/hw/supermicro_gb300.rs b/crates/bmc-explorer/src/hw/supermicro_gb300.rs new file mode 100644 index 0000000000..6f300423cc --- /dev/null +++ b/crates/bmc-explorer/src/hw/supermicro_gb300.rs @@ -0,0 +1,29 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use crate::hw::BiosAttr; + +/// Setup attributes exposed by the Supermicro OpenBMC firmware on GB300. +/// +/// Unlike GB200, this platform does not expose `TPM`, `EmbeddedUefiShell`, or +/// `SecureBootEnable`. `SecurityDeviceSupport` is its TPM control, while the +/// PCIe option ROMs must be enabled for the host to expose the DPU boot target. +pub const EXPECTED_BIOS_ATTRS: [BiosAttr; 3] = [ + BiosAttr::new_str("SecurityDeviceSupport", "Enabled"), + BiosAttr::new_bool("Socket0Pcie6DisableOptionROM", false), + BiosAttr::new_bool("Socket1Pcie6DisableOptionROM", false), +]; diff --git a/crates/bmc-explorer/src/lib.rs b/crates/bmc-explorer/src/lib.rs index 45505b3769..9702a0439c 100644 --- a/crates/bmc-explorer/src/lib.rs +++ b/crates/bmc-explorer/src/lib.rs @@ -389,9 +389,7 @@ pub(crate) fn hw_type( { return Some(hw::HwType::DgxGb300); } - // SMC GB300: Supermicro host BMC. The tray scrape shows ServiceRoot vendor "Supermicro" - // (Product "GB NVL", no OEM key), so the vendor string carries it -- no chassis helper - // needed. See gb300-firmus-ingestion/triangulation-matrix.md. + // SMC GB300: Supermicro OpenBMC host. if root.vendor() == Some(Vendor::new("Supermicro")) { return Some(hw::HwType::SupermicroGb300); } @@ -1058,11 +1056,10 @@ fn machine_setup_status( } } - hw::HwType::DgxGb300 | hw::HwType::SupermicroGb300 => { - // GB300 platforms (DGX on the NVIDIA "GB BMC", SMC on a Supermicro OpenBMC) share - // the platform-level setup expectations: secure boot off and boot order by MAC. - // TODO(gb300): add per-ODM EXPECTED_BIOS_ATTRS tables once each GB300 tray's - // BIOS is characterized; until then no BIOS-attr verification is applied. + hw::HwType::DgxGb300 => { + // DGX GB300 on the NVIDIA "GB BMC" uses the platform-level setup expectations: + // secure boot off and boot order by MAC. + // TODO(dgx-gb300): add EXPECTED_BIOS_ATTRS once the tray BIOS is characterized. if explored_system .secure_boot_status() .is_ok_and(|s| s.is_enabled) @@ -1088,6 +1085,31 @@ fn machine_setup_status( } } } + + hw::HwType::SupermicroGb300 => { + // Supermicro GB300 uses the GBx00 OpenBMC flow, but its firmware does not expose + // SecureBootEnable or EmbeddedUefiShell. Verify only the controls present in the + // real tray: TPM support and the DPU-facing PCIe option ROMs. + diffs.extend( + hw::supermicro_gb300::EXPECTED_BIOS_ATTRS + .iter() + .flat_map(|expected| explored_system.verify_bios_attr(expected)), + ); + if let Some(mac) = boot_interface_mac { + let actual = explored_system.boot_order_first_option(); + let mac_str = format!("/MAC({},", mac.to_string().replace(":", "")); + let expected = explored_system.boot_options.iter().find(|option| { + option.uefi_device_path().is_some_and(|path| { + path.inner().contains(&mac_str) + && path.inner().contains("/IPv4(") + && path.inner().ends_with("/Uri()") + }) + }); + if let Some(diff) = compare_boot_options(expected, actual) { + diffs.push(diff) + } + } + } } MachineSetupStatus { diff --git a/crates/bmc-explorer/tests/integration/supermicro_gb300_explore.rs b/crates/bmc-explorer/tests/integration/supermicro_gb300_explore.rs index 9537d65b8d..a783ab53b1 100644 --- a/crates/bmc-explorer/tests/integration/supermicro_gb300_explore.rs +++ b/crates/bmc-explorer/tests/integration/supermicro_gb300_explore.rs @@ -54,4 +54,26 @@ async fn explore_supermicro_gb300() { ); assert!(!report.systems.is_empty(), "systems must be present"); assert!(!report.chassis.is_empty(), "chassis must be present"); + + let setup = report + .machine_setup_status + .expect("SMC GB300 must report machine setup status"); + assert!(!setup.is_done); + assert_eq!( + setup + .diffs + .iter() + .map(|diff| { + ( + diff.key.as_str(), + diff.expected.as_str(), + diff.actual.as_str(), + ) + }) + .collect::>(), + [ + ("Socket0Pcie6DisableOptionROM", "false", "true"), + ("Socket1Pcie6DisableOptionROM", "false", "true"), + ] + ); } diff --git a/crates/bmc-mock/src/hw/supermicro_gb300_nvl.rs b/crates/bmc-mock/src/hw/supermicro_gb300_nvl.rs index 6a3c05e3d9..e3b5ee1db3 100644 --- a/crates/bmc-mock/src/hw/supermicro_gb300_nvl.rs +++ b/crates/bmc-mock/src/hw/supermicro_gb300_nvl.rs @@ -124,7 +124,7 @@ impl SupermicroGB300Nvl<'_> { let system_id = "System_0"; let boot_options = std::iter::once( redfish::boot_option::builder( - &redfish::boot_option::resource(system_id, "0002"), + &redfish::boot_option::resource(system_id, "Boot0002"), BootOptionKind::Disk, ) .boot_option_reference("Boot0002") @@ -136,21 +136,20 @@ impl SupermicroGB300Nvl<'_> { .into_iter() .enumerate() .map(|(n, nic)| { - let id = format!("{:04X}", n + 3); // Starting with 0003 + let id = format!("Boot{:04X}", n + 3); // Starting with Boot0003 let pci_path = "PciRoot(0x0)/Pci(0x10,0x0)/Pci(0x0,0x0)"; redfish::boot_option::builder( &redfish::boot_option::resource(system_id, &id), BootOptionKind::Network, ) - .boot_option_reference(&format!("Boot{id}")) + .boot_option_reference(&id) .display_name(&format!( - "UEFI HTTP IPv4 Nvidia Network Adapter - {} - {}", - nic.mac_address, + "UEFI HTTPv4 (MAC:{})", nic.mac_address.to_string().replace(":", "") )) .uefi_device_path(&format!( "{pci_path}/MAC({},0x1)\ - /IPv4(0.0.0.0,0x0,DHCP,0.0.0.0,0.0.0.0,0.0.0.0)/Uri()", + /IPv4(0.0.0.0,0x0,DHCP,0.0.0.0,0.0.0.0,0.0.0.0)/Uri()", nic.mac_address.to_string().replace(":", "") )) .build() @@ -183,7 +182,7 @@ impl SupermicroGB300Nvl<'_> { base_bios: Some(base_bios(system_id)), bios_mode: redfish::computer_system::BiosMode::Generic, boot_options: Some(boot_options), - boot_order_mode: redfish::computer_system::BootOrderMode::OrderedCollection, + boot_order_mode: redfish::computer_system::BootOrderMode::ViaSettings, chassis: vec!["Chassis_0".into()], eth_interfaces: None, id: system_id.into(), @@ -193,7 +192,9 @@ impl SupermicroGB300Nvl<'_> { model: Some("GB NVL".into()), oem: redfish::computer_system::Oem::Generic, callbacks: Some(callbacks), - secure_boot_available: true, + // This firmware exposes the SecureBoot resource but omits + // SecureBootEnable, so there is no usable status to report. + secure_boot_available: false, serial_console: Some( redfish::serial_console::builder() .max_concurrent_sessions(1) @@ -299,12 +300,13 @@ impl SupermicroGB300Nvl<'_> { } fn base_bios(system_id: &str) -> serde_json::Value { - // libredfish uses this attribute to detect whether this BMC spells the - // enabled TPM state as "Enable" or "Enabled" before building its setup - // request. The suffixed key and value mirror a real Supermicro fixture. + // Security device support is already enabled; the DPU-facing option ROMs + // still need to be enabled by clearing their DisableOptionROM controls. redfish::bios::builder(&redfish::bios::resource(system_id)) .attributes(json!({ - "SecurityDeviceSupport_005A": "Enable", + "SecurityDeviceSupport": "Enabled", + "Socket0Pcie6DisableOptionROM": true, + "Socket1Pcie6DisableOptionROM": true, })) .build() } diff --git a/pxe/Makefile.toml b/pxe/Makefile.toml index 7513d1134c..e49ece117f 100644 --- a/pxe/Makefile.toml +++ b/pxe/Makefile.toml @@ -108,10 +108,16 @@ dependencies = [ ] [tasks.stage-scout-loader-rclocal] -description = "Copies the rc.local script to the scout loader profile directories" +description = "Copies the Scout loader helpers to the scout loader profile directories" script = ''' cp ${REPO_ROOT}/pxe/common_files/scout-loader-rclocal ${REPO_ROOT}/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.extra/etc/rc.local cp ${REPO_ROOT}/pxe/common_files/scout-loader-rclocal ${REPO_ROOT}/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.extra/etc/rc.local + + mkdir -p ${REPO_ROOT}/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.extra/opt/forge/ + cp ${REPO_ROOT}/pxe/common_files/forge-scout-network.sh ${REPO_ROOT}/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.extra/opt/forge/ + + mkdir -p ${REPO_ROOT}/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.extra/opt/forge/ + cp ${REPO_ROOT}/pxe/common_files/forge-scout-network.sh ${REPO_ROOT}/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.extra/opt/forge/ ''' [tasks.stage-scout-update-check] @@ -196,6 +202,7 @@ dependencies = [ dependencies = [ "mkdir-static", { name = "package-scout-aarch64-release-cross", path = "${REPO_ROOT}" }, + "create-ephemeral-image-arm-host", "bfb-aarch64-sa", "ipxe-aarch64-sa", "setup-apt-repo-arm64", diff --git a/pxe/common_files/forge-scout-network.sh b/pxe/common_files/forge-scout-network.sh index 9a57cf80d8..2b1a504d53 100755 --- a/pxe/common_files/forge-scout-network.sh +++ b/pxe/common_files/forge-scout-network.sh @@ -24,6 +24,16 @@ ip_command=${SCOUT_IP_COMMAND:-ip} networkctl_command=${SCOUT_NETWORKCTL_COMMAND:-networkctl} networkd_runtime_dir=${SCOUT_NETWORKD_RUNTIME_DIR:-/run/systemd/network} networkd_dhcp_file=${SCOUT_NETWORKD_DHCP_FILE:-/etc/systemd/network/dhcp.network} +# The boot NIC is frequently not usable yet when this script first runs. The kernel +# probes PCI devices in domain order, so the interface named by `mac=` can appear +# tens of seconds into boot -- on a GB300 compute tray the BlueField-3 boot NIC sits +# on domain 0016 and is probed *after* four ConnectX-8s, ~24s in, while the loader +# invokes this script at ~9s. Waiting for the interface to appear, gain carrier and +# lease an address is therefore required for correctness, not just robustness: +# without it the readiness checks below simply find nothing and the whole filter +# silently no-ops on exactly the multi-NIC hosts it exists to serve. +network_wait_seconds=${SCOUT_NETWORK_WAIT_SECONDS:-60} +network_poll_interval=${SCOUT_NETWORK_POLL_INTERVAL:-1} if ! cmdline=$(cat "$cmdline_file"); then echo "Skipping Scout network configuration: reason=cmdline_unreadable" >&2 @@ -58,41 +68,62 @@ case "$preferred_mac" in esac preferred_mac=$(printf '%s\n' "$preferred_mac" | tr '[:upper:]' '[:lower:]') +probe_attempts=0 +probe_max_attempts=$((network_wait_seconds / network_poll_interval)) +[ "$probe_max_attempts" -lt 1 ] && probe_max_attempts=1 + preferred_interface= -preferred_interface_count=0 -for net_path in "$sys_class_net"/* +while : do - [ -e "$net_path" ] || continue - [ -r "$net_path/address" ] || continue + preferred_interface= + preferred_interface_count=0 + for net_path in "$sys_class_net"/* + do + [ -e "$net_path" ] || continue + [ -r "$net_path/address" ] || continue - interface_mac=$(cat "$net_path/address") || continue - interface_mac=$(printf '%s\n' "$interface_mac" | tr '[:upper:]' '[:lower:]') - if [ "$interface_mac" = "$preferred_mac" ]; then - preferred_interface=${net_path##*/} - preferred_interface_count=$((preferred_interface_count + 1)) + interface_mac=$(cat "$net_path/address") || continue + interface_mac=$(printf '%s\n' "$interface_mac" | tr '[:upper:]' '[:lower:]') + if [ "$interface_mac" = "$preferred_mac" ]; then + preferred_interface=${net_path##*/} + preferred_interface_count=$((preferred_interface_count + 1)) + fi + done + + # More than one interface owning the same MAC is a configuration fault, not a + # timing one -- waiting cannot resolve it, so give up immediately. + if [ "$preferred_interface_count" -gt 1 ]; then + echo "Skipping Scout network configuration: reason=preferred_interface_count count=$preferred_interface_count" >&2 + exit 0 fi -done -if [ "$preferred_interface_count" -ne 1 ]; then - echo "Skipping Scout network configuration: reason=preferred_interface_count count=$preferred_interface_count" >&2 - exit 0 -fi + not_ready= + if [ "$preferred_interface_count" -ne 1 ]; then + not_ready=no_interface + else + carrier_file="$sys_class_net/$preferred_interface/carrier" + # Reading `carrier` fails with EINVAL while the link is administratively + # down, so treat an unreadable value the same as "no carrier yet". + if [ ! -r "$carrier_file" ] || [ "$(cat "$carrier_file" 2>/dev/null)" != 1 ]; then + not_ready=no_carrier + elif ! global_addresses=$("$ip_command" -o address show dev "$preferred_interface" scope global); then + not_ready=address_inspection_failed + elif [ -z "$global_addresses" ]; then + not_ready=no_global_address + fi + fi -carrier_file="$sys_class_net/$preferred_interface/carrier" -if [ ! -r "$carrier_file" ] || [ "$(cat "$carrier_file")" != 1 ]; then - echo "Skipping Scout network configuration: interface=$preferred_interface reason=no_carrier" >&2 - exit 0 -fi + [ -z "$not_ready" ] && break -if global_addresses=$("$ip_command" -o address show dev "$preferred_interface" scope global); then - if [ -z "$global_addresses" ]; then - echo "Skipping Scout network configuration: interface=$preferred_interface reason=no_global_address" >&2 - exit 0 + probe_attempts=$((probe_attempts + 1)) + if [ "$probe_attempts" -ge "$probe_max_attempts" ]; then + # Non-zero: the caller retries and reports. Exiting 0 here would mask a + # real failure as success and leave every NIC running DHCP. + echo "Scout network configuration timed out: interface=${preferred_interface:-} mac=$preferred_mac reason=$not_ready waited=${network_wait_seconds}s" >&2 + exit 1 fi -else - echo "Skipping Scout network configuration: interface=$preferred_interface reason=address_inspection_failed" >&2 - exit 0 -fi + sleep "$network_poll_interval" +done runtime_network_file="$networkd_runtime_dir/00-forge-scout-nonpreferred.network" diff --git a/pxe/common_files/scout-loader-rclocal b/pxe/common_files/scout-loader-rclocal index d6e9721248..ebf48609b2 100755 --- a/pxe/common_files/scout-loader-rclocal +++ b/pxe/common_files/scout-loader-rclocal @@ -204,9 +204,26 @@ then detect_pcr_hash DONE=0 + NIC_FILTERED=0 send_msg "LOADER: Downloading ${newrootfsurl}" + while (( ${DONE} != 1 )) do + # Retried until it succeeds rather than attempted once: the boot NIC may not + # have been probed yet on the first pass (see forge-scout-network.sh), and a + # single early no-op leaves every NIC running DHCP -- which on a multi-homed + # host means competing default routes and an unreachable provisioning server. + if (( ${NIC_FILTERED} != 1 )) && [ -x /opt/forge/forge-scout-network.sh ] + then + send_msg "LOADER: Selecting boot NIC from kernel mac= parameter" + if /opt/forge/forge-scout-network.sh + then + NIC_FILTERED=1 + else + send_msg "LOADER: Scout NIC filtering incomplete; retrying" + fi + fi + # We store the HTTP HEAD info for the script which will check for updates later. curl -sSf --head "${newrootfsurl}" 2> "${CURL_ERR}" | sed 's/\r//g' > "${ROOTFS_INFO_TMP}" if (( $? == 0 )) diff --git a/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.conf b/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.conf index 56858c4240..feb4c13787 100644 --- a/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.conf +++ b/pxe/mkosi.profiles/scout-loader-aarch64/mkosi.conf @@ -24,6 +24,7 @@ Packages= dbus file isc-dhcp-client + iproute2 kmod linux-nvidia-64k-hwe-24.04 net-tools diff --git a/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.conf b/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.conf index 559f220b42..90422d580c 100644 --- a/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.conf +++ b/pxe/mkosi.profiles/scout-loader-x86_64/mkosi.conf @@ -22,6 +22,7 @@ Packages= curl dbus isc-dhcp-client + iproute2 kmod linux-image-6.8.0-111-generic net-tools diff --git a/pxe/mkosi.profiles/scout-oss-aarch64/mkosi.conf b/pxe/mkosi.profiles/scout-oss-aarch64/mkosi.conf index 7b66b2e2b7..1c4e970b57 100644 --- a/pxe/mkosi.profiles/scout-oss-aarch64/mkosi.conf +++ b/pxe/mkosi.profiles/scout-oss-aarch64/mkosi.conf @@ -40,6 +40,7 @@ Packages= ipmitool iproute2 iputils-ping + iproute2 keyboard-configuration isc-dhcp-client lldpd diff --git a/pxe/mkosi.profiles/scout-oss-x86_64/mkosi.conf b/pxe/mkosi.profiles/scout-oss-x86_64/mkosi.conf index 0fda93d7f9..db205d9f5d 100644 --- a/pxe/mkosi.profiles/scout-oss-x86_64/mkosi.conf +++ b/pxe/mkosi.profiles/scout-oss-x86_64/mkosi.conf @@ -39,6 +39,7 @@ Packages= ipmitool iproute2 iputils-ping + iproute2 keyboard-configuration isc-dhcp-client lldpd From f594b17cc348977c3c0026d335fea37ae89fed3d Mon Sep 17 00:00:00 2001 From: Patrice Breton Date: Fri, 7 Aug 2026 15:16:25 -0700 Subject: [PATCH 08/26] patch(v2.1): use lowercase phone_home post key (#4692) Backport of #4670 to `release/v2.1`. ## What changed - Use the lowercase `post` property in the cloud-init `phone_home` configuration. - Add schema-backed coverage for the generated nested `autoinstall.user-data` phone-home configuration. ## Why Ubuntu validates nested cloud-config strictly and rejects the uppercase `POST` property, leaving affected installations stuck in `Provisioning`. Cloud-init mandates the lowercase `post` property. ## Validation - `go test ./api/pkg/api/model/util` Ref: 6569456 --------- Signed-off-by: Patrice Breton Co-authored-by: Reuben Elliott --- .../cloud-init-phone-home.schema.json | 53 +++++++++++++++++++ rest-api/api/pkg/api/model/util/util.go | 2 +- rest-api/api/pkg/api/model/util/util_test.go | 22 ++++++++ rest-api/go.mod | 2 +- 4 files changed, 77 insertions(+), 2 deletions(-) create mode 100644 rest-api/api/pkg/api/model/util/testdata/cloud-init-phone-home.schema.json diff --git a/rest-api/api/pkg/api/model/util/testdata/cloud-init-phone-home.schema.json b/rest-api/api/pkg/api/model/util/testdata/cloud-init-phone-home.schema.json new file mode 100644 index 0000000000..06f653b3b8 --- /dev/null +++ b/rest-api/api/pkg/api/model/util/testdata/cloud-init-phone-home.schema.json @@ -0,0 +1,53 @@ +{ + "$schema": "http://json-schema.org/draft-04/schema#", + "description": "The cc_phone_home schema from https://github.com/canonical/cloud-init/blob/26.1/cloudinit/config/schemas/schema-cloud-config-v1.json#L2351-L2398.", + "type": "object", + "required": [ + "phone_home" + ], + "properties": { + "phone_home": { + "type": "object", + "required": [ + "url" + ], + "additionalProperties": false, + "properties": { + "url": { + "type": "string", + "format": "uri", + "description": "The URL to send the phone home data to." + }, + "post": { + "description": "A list of keys to post or ``all``. Default: ``all``.", + "oneOf": [ + { + "enum": [ + "all" + ] + }, + { + "type": "array", + "items": { + "type": "string", + "enum": [ + "pub_key_rsa", + "pub_key_ecdsa", + "pub_key_ed25519", + "instance_id", + "hostname", + "fqdn" + ] + } + } + ] + }, + "tries": { + "type": "integer", + "description": "The number of times to try sending the phone home data. Default: ``10``.", + "default": 10 + } + } + } + } +} diff --git a/rest-api/api/pkg/api/model/util/util.go b/rest-api/api/pkg/api/model/util/util.go index 2e61a0b6d0..7fecf3b651 100644 --- a/rest-api/api/pkg/api/model/util/util.go +++ b/rest-api/api/pkg/api/model/util/util.go @@ -16,7 +16,7 @@ import ( const ( // configuration for phone home SitePhoneHomeName = "phone_home" - SitePhoneHomePost = "POST" + SitePhoneHomePost = "post" SitePhoneHomePostAll = "all" SitePhoneHomeUrl = "url" SiteCloudConfig = "#cloud-config" diff --git a/rest-api/api/pkg/api/model/util/util_test.go b/rest-api/api/pkg/api/model/util/util_test.go index 7a89a33d22..ba5296281a 100644 --- a/rest-api/api/pkg/api/model/util/util_test.go +++ b/rest-api/api/pkg/api/model/util/util_test.go @@ -6,11 +6,33 @@ package util import ( "testing" + "github.com/santhosh-tekuri/jsonschema/v6" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "gopkg.in/yaml.v3" ) +func TestInsertedPhoneHomeMatchesCloudInitSchema(t *testing.T) { + documentRoot := unmarshalDocumentRoot(t, `autoinstall: + version: 1 +`) + require.NoError(t, InsertPhoneHomeIntoUserData(documentRoot, "http://169.254.169.254/phone_home")) + + autoinstallNode := mappingNodeValue(documentRoot, "autoinstall") + require.NotNil(t, autoinstallNode) + targetUserDataNode := mappingNodeValue(autoinstallNode, "user-data") + require.NotNil(t, targetUserDataNode) + + var targetUserData any + require.NoError(t, targetUserDataNode.Decode(&targetUserData)) + + compiler := jsonschema.NewCompiler() + compiler.AssertFormat() + schema, err := compiler.Compile("testdata/cloud-init-phone-home.schema.json") + require.NoError(t, err) + require.NoError(t, schema.Validate(targetUserData)) +} + func TestInsertPhoneHomeIntoUserData(t *testing.T) { const phoneHomeURL = "http://169.254.169.254/phone-home" diff --git a/rest-api/go.mod b/rest-api/go.mod index f8931714da..1cf2c3878b 100644 --- a/rest-api/go.mod +++ b/rest-api/go.mod @@ -54,6 +54,7 @@ require ( github.com/robfig/cron/v3 v3.0.1 github.com/rs/zerolog v1.33.0 github.com/samber/lo v1.52.0 + github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 github.com/sirupsen/logrus v1.9.4 github.com/spf13/cast v1.10.0 github.com/spf13/cobra v1.10.2 @@ -370,7 +371,6 @@ require ( github.com/ryanuber/go-glob v1.0.0 // indirect github.com/sagikazarmark/locafero v0.11.0 // indirect github.com/sanposhiho/wastedassign/v2 v2.1.0 // indirect - github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 // indirect github.com/sashamelentyev/interfacebloat v1.1.0 // indirect github.com/sashamelentyev/usestdlibvars v1.29.0 // indirect github.com/securego/gosec/v2 v2.26.1 // indirect From cc6909dc9cd10dcfc82edf7d5d7c7488c3af3be4 Mon Sep 17 00:00:00 2001 From: nv-dmendoza <117955115+nv-dmendoza@users.noreply.github.com> Date: Fri, 7 Aug 2026 15:47:23 -0700 Subject: [PATCH 09/26] patch(v2.1): trufflehog scan base for PRs first commit (#4726) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backports #4715 This fixes the trufflehog scan job for PRs on their first CI push and for tag pushes. On a PR's first push, GitHub sets github.event.before to the all-zeros SHA (`0000000000000000000000000000000000000000`) because the branch is new. The trufflehog action treats this as an absent base, causing TruffleHog to scan the entire repository history (~444 MB) instead of just the commits introduced by the PR. Scanning the full history triggers hundreds of false-positive "verified Lob" findings (TruffleHog #5184 (https://github.com/trufflesecurity/trufflehog/issues/5184)). The fix detects the all-zeros case and looks up the PR's actual target branch via the GitHub API, then computes the real merge base: ```bash # Before: base was empty, TruffleHog scanned all of history base: ${{ github.event.before }} # "0000000000000000000000000000000000000000" # After: merge base is resolved explicitly PR_NUM="${GITHUB_REF_NAME##pull-request/}" BASE_BRANCH=$(curl ... /pulls/${PR_NUM} | jq -r '.base.ref') BEFORE=$(git merge-base "origin/${BASE_BRANCH}" HEAD) # After (tag): merge base resolved against previous tag PREV_TAG=$(git tag --sort=-version:refname | grep -v "^${GITHUB_REF_NAME}$" | head -1) BEFORE=$(git merge-base "refs/tags/${PREV_TAG}" HEAD) ``` Tag pushes have the same all-zeros problem since the tag ref is also new, so the fix handles those too — finding the most recent previous tag and computing the merge base against it. On subsequent pushes to the same PR branch and on pushes to main, `github.event.before` is a real commit SHA so the logic is skipped and behavior is unchanged. | Scenario | `github.event.before` | `GITHUB_REF` | Before fix | After fix | |---|---|---|---|---| | PR — first push | `000...000` | `refs/heads/pull-request/*` | TruffleHog scans full repo history, hundreds of false-positive Lob findings, exit 183 | Resolves merge base via API, scans only PR commits | | PR — subsequent pushes | real SHA | `refs/heads/pull-request/*` | Scans commits since last push (correct) | Same — `if` block skipped, unchanged | | Push to `main` | real SHA | `refs/heads/main` | Scans commits since last push (correct) | Same — `if` block skipped, unchanged | | Tag push | `000...000` | `refs/tags/*` | TruffleHog scans full repo history | scans commits since last tag | ## Related issues ## Type of Change - [ ] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [ ] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [x] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [ ] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [x] No testing required (docs, internal refactor, etc.) ## Additional Notes --- .github/workflows/ci.yaml | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index fbb23ba4a0..1fbfc9444a 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -1193,9 +1193,39 @@ jobs: persist-credentials: false fetch-depth: 0 # Full history for secret scanning + # On a PR's first push, github.event.before is all zeros because the branch + # is new. Without an explicit base, TruffleHog scans the entire repo history + # instead of just the commits on this PR. We look up the PR's actual target + # branch and compute the merge base so the scan is scoped to this PR only. + - name: Compute TruffleHog scan base + id: scan-base + env: + GH_TOKEN: ${{ github.token }} + run: | + BEFORE="${{ github.event.before }}" + if [[ ("$BEFORE" == "0000000000000000000000000000000000000000" || -z "$BEFORE") && "$GITHUB_REF" == refs/heads/pull-request/* ]]; then + PR_NUM="${GITHUB_REF_NAME##pull-request/}" + BASE_BRANCH=$(curl -fsSL \ + -H "Authorization: Bearer $GH_TOKEN" \ + -H "Accept: application/vnd.github+json" \ + "https://api.github.com/repos/${{ github.repository }}/pulls/${PR_NUM}" \ + | jq -r '.base.ref') + BEFORE=$(git merge-base "origin/${BASE_BRANCH}" HEAD) + elif [[ "$GITHUB_REF" == refs/tags/* ]]; then + # Tag pushes also have an all-zeros before. Scope the scan to commits + # since the previous tag so we don't re-scan the entire history on + # every release. + PREV_TAG=$(git tag --sort=-version:refname | grep -v "^${GITHUB_REF_NAME}$" | head -1) + if [[ -n "$PREV_TAG" ]]; then + BEFORE=$(git merge-base "refs/tags/${PREV_TAG}" HEAD) + fi + fi + echo "base=$BEFORE" >> "$GITHUB_OUTPUT" + - name: Run TruffleHog Scan uses: NVIDIA/dsx-github-actions/.github/actions/trufflehog-scan@9a9ce3a7770a8b53d2726afa920be3276bc3ddd7 with: + base: ${{ steps.scan-base.outputs.base }} extra-args: '--results=verified,unknown --only-verified' post-pr-comment: 'false' fail-on-findings: 'true' From 0c0b4d84c7e1d274417ef1572806fb9b5825767c Mon Sep 17 00:00:00 2001 From: spydaNVIDIA Date: Mon, 10 Aug 2026 09:33:11 -0700 Subject: [PATCH 10/26] feat(machine-controller): add DPU UEFI credential rotation (#4758) Extend Ready-only UEFI rotation to DPUs with a dedicated RotatingDpuUefi state that converges one DPU per cycle (stage BIOS settings -> DPU restart -> record), keyed by the DPU BMC MAC and reusing the site-wide uefi_rotation_enabled flag, per-machine force flag, versioned credential candidates, and backoff/quarantine bookkeeping. Add SetDpuUefiPassword RPC + `dpu set-uefi-password` CLI + RBAC for the direct-on-device path, and confirm TriggerUefiCredentialRotation resolves DPU BMC MACs. ## Related issues https://github.com/NVIDIA/infra-controller/issues/367 ## Type of Change - [x] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [ ] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [x] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) ## Additional Notes ## Related issues ## Type of Change - [x] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [ ] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [x] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) ## Additional Notes --- crates/admin-cli/src/dpu/mod.rs | 3 + .../src/dpu/set_uefi_password/args.rs | 49 + .../src/dpu/set_uefi_password/cmd.rs | 30 + .../src/dpu/set_uefi_password/mod.rs | 31 + crates/api-core/src/api.rs | 7 + .../api-core/src/auth/internal_rbac_rules.rs | 1 + crates/api-core/src/cfg/README.md | 2 +- crates/api-core/src/cfg/file.rs | 2 +- crates/api-core/src/handlers/uefi.rs | 181 + .../src/handlers/uefi_credential_rotation.rs | 15 +- crates/api-core/src/setup.rs | 5 +- .../src/tests/common/api_fixtures/mod.rs | 11 +- .../bmc_rotation.rs | 4 +- .../switch_state_controller/bmc_rotation.rs | 2 +- ...0004_bmc_credential_rotation_requested.sql | 2 +- ...itch_bmc_credential_rotation_requested.sql | 2 +- ...helf_bmc_credential_rotation_requested.sql | 2 +- crates/api-db/src/power_shelf.rs | 4 +- crates/api-db/src/switch.rs | 6 +- crates/api-model/src/machine/mod.rs | 33 +- crates/api-model/src/machine/slas.rs | 10 +- crates/api-model/src/power_shelf/mod.rs | 4 +- crates/api-model/src/switch/mod.rs | 4 +- crates/machine-controller/src/config/mod.rs | 8 +- crates/machine-controller/src/context.rs | 7 +- crates/machine-controller/src/handler.rs | 19 + .../src/handler/dpu_uefi_rotation.rs | 463 + .../src/handler/host_boot_config.rs | 5 +- .../src/handler/host_uefi_rotation.rs | 4 +- .../src/handler/rotation.rs | 2 +- crates/machine-controller/src/io.rs | 1 + .../tests/integration/bmc_rotation.rs | 2 +- .../tests/integration/dpu_uefi_rotation.rs | 380 + .../tests/integration/env.rs | 7 +- .../tests/integration/main.rs | 1 + crates/power-shelf-controller/src/context.rs | 2 +- .../src/rotating_bmc.rs | 2 +- crates/redfish/src/libredfish/mod.rs | 31 +- crates/rpc/proto/forge.proto | 18 + crates/switch-controller/src/context.rs | 2 +- crates/switch-controller/src/rotating_bmc.rs | 2 +- rest-api/proto/core/gen/v1/nico_nico.pb.go | 7925 +++++++++-------- .../proto/core/gen/v1/nico_nico_grpc.pb.go | 44 + rest-api/proto/core/src/v1/nico_nico.proto | 18 + 44 files changed, 5385 insertions(+), 3968 deletions(-) create mode 100644 crates/admin-cli/src/dpu/set_uefi_password/args.rs create mode 100644 crates/admin-cli/src/dpu/set_uefi_password/cmd.rs create mode 100644 crates/admin-cli/src/dpu/set_uefi_password/mod.rs create mode 100644 crates/machine-controller/src/handler/dpu_uefi_rotation.rs create mode 100644 crates/machine-controller/tests/integration/dpu_uefi_rotation.rs diff --git a/crates/admin-cli/src/dpu/mod.rs b/crates/admin-cli/src/dpu/mod.rs index 15c7d7394c..67e169318e 100644 --- a/crates/admin-cli/src/dpu/mod.rs +++ b/crates/admin-cli/src/dpu/mod.rs @@ -19,6 +19,7 @@ mod agent_upgrade_policy; mod health_report; mod network; mod reprovision; +mod set_uefi_password; mod status; mod versions; @@ -50,4 +51,6 @@ pub enum Cmd { visible_alias = "hr" )] HealthReport(health_report::Args), + #[clap(about = "Set DPU UEFI password directly on the device (via Redfish)")] + SetUefiPassword(set_uefi_password::Args), } diff --git a/crates/admin-cli/src/dpu/set_uefi_password/args.rs b/crates/admin-cli/src/dpu/set_uefi_password/args.rs new file mode 100644 index 0000000000..38603d0738 --- /dev/null +++ b/crates/admin-cli/src/dpu/set_uefi_password/args.rs @@ -0,0 +1,49 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use ::rpc::forge::SetDpuUefiPasswordRequest; +use clap::Parser; + +use crate::machine::MachineQuery; + +// Args wraps the shared MachineQuery as a subcommand +// specific newtype to allow sharing of MachineQuery, and still +// providing a subcommand-specific Run trait implementation. +#[derive(Parser, Debug, Clone)] +#[command(after_long_help = "\ +EXAMPLES: + +Set the UEFI password for a DPU by machine ID: + $ nico-admin-cli dpu set-uefi-password --query fm100ds038bg3qsho433vkg684heguv282qaggmrsh2ugn1qk096n2c6hcg + +Set the UEFI password for a DPU selected by its BMC MAC address: + $ nico-admin-cli dpu set-uefi-password --query 00:11:22:33:44:55 + +")] +pub struct Args { + #[clap(flatten)] + pub inner: MachineQuery, +} + +impl From for SetDpuUefiPasswordRequest { + fn from(args: Args) -> Self { + Self { + dpu_id: None, + machine_query: Some(args.inner.query), + } + } +} diff --git a/crates/admin-cli/src/dpu/set_uefi_password/cmd.rs b/crates/admin-cli/src/dpu/set_uefi_password/cmd.rs new file mode 100644 index 0000000000..90e66fe572 --- /dev/null +++ b/crates/admin-cli/src/dpu/set_uefi_password/cmd.rs @@ -0,0 +1,30 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +use super::args::Args; +use crate::errors::CarbideCliResult; +use crate::rpc::ApiClient; + +pub async fn set_uefi_password(data: Args, api_client: &ApiClient) -> CarbideCliResult<()> { + api_client.0.set_dpu_uefi_password(data).await?; + // A DPU stages the change through Redfish BIOS settings and schedules no job; + // it commits on the next DPU restart, so there is no job id to report. + println!( + "successfully staged the site-wide UEFI password on the DPU; it commits on the next DPU restart" + ); + Ok(()) +} diff --git a/crates/admin-cli/src/dpu/set_uefi_password/mod.rs b/crates/admin-cli/src/dpu/set_uefi_password/mod.rs new file mode 100644 index 0000000000..56571ed418 --- /dev/null +++ b/crates/admin-cli/src/dpu/set_uefi_password/mod.rs @@ -0,0 +1,31 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +pub mod args; +pub mod cmd; + +pub use args::Args; + +use crate::cfg::run::Run; +use crate::cfg::runtime::RuntimeContext; +use crate::errors::CarbideCliResult; + +impl Run for Args { + async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> { + cmd::set_uefi_password(self, &ctx.api_client).await + } +} diff --git a/crates/api-core/src/api.rs b/crates/api-core/src/api.rs index 172b19b863..057b70a3e7 100644 --- a/crates/api-core/src/api.rs +++ b/crates/api-core/src/api.rs @@ -1602,6 +1602,13 @@ impl Forge for Api { crate::handlers::uefi::set_host_uefi_password(self, request).await } + async fn set_dpu_uefi_password( + &self, + request: Request, + ) -> Result, Status> { + crate::handlers::uefi::set_dpu_uefi_password(self, request).await + } + async fn get_expected_machine( &self, request: Request, diff --git a/crates/api-core/src/auth/internal_rbac_rules.rs b/crates/api-core/src/auth/internal_rbac_rules.rs index de9ccf2545..c9b705d8dc 100644 --- a/crates/api-core/src/auth/internal_rbac_rules.rs +++ b/crates/api-core/src/auth/internal_rbac_rules.rs @@ -329,6 +329,7 @@ impl InternalRBACRules { x.perm("UpdateInstancePhoneHomeLastContact", vec![Agent]); x.perm("SetHostUefiPassword", vec![ForgeAdminCLI]); x.perm("ClearHostUefiPassword", vec![ForgeAdminCLI]); + x.perm("SetDpuUefiPassword", vec![ForgeAdminCLI]); x.perm( "AddExpectedMachine", vec![ForgeAdminCLI, SiteAgent, Flow, Machineatron], diff --git a/crates/api-core/src/cfg/README.md b/crates/api-core/src/cfg/README.md index df26ad7bb4..aca938884c 100644 --- a/crates/api-core/src/cfg/README.md +++ b/crates/api-core/src/cfg/README.md @@ -52,7 +52,7 @@ applicable. | `vpc_peering_policy_on_existing` | `Option` | — | `networking` | Policy for whether existing VPC peerings should be active. | | `attestation_enabled` | `bool` | `false` | `security` | Enables TPM-based machine attestation (adds `Measuring` state before `Ready`). | | `bmc_rotation_enabled` | `bool` | `false` | `security` | Site-wide kill-switch for passive BMC credential rotation. When `false` (default), a Ready host never auto-enters `RotatingBmc`; the force-converge escape hatch bypasses it. | -| `uefi_rotation_enabled` | `bool` | `false` | `security` | Site-wide kill-switch for passive UEFI credential rotation. When `false` (default), a Ready host never auto-enters `RotatingHostUefi`; the force-converge escape hatch bypasses it. | +| `uefi_rotation_enabled` | `bool` | `false` | `security` | Site-wide kill-switch for passive UEFI credential rotation (host and DPU). When `false` (default), a Ready host never auto-enters `RotatingHostUefi` nor drives its DPUs into `RotatingDpuUefi`; the per-machine force-converge escape hatch bypasses it. | | `tpm_required` | `bool` | `true` | `security` | Require TPM module for machine registration. **Testing only** when `false`. | | `machine_state_controller` | `MachineStateControllerConfig` | *(see below)* | `machines` | Machine state controller timing (see [MachineStateControllerConfig](#machinestatecontrollerconfig)). | | `network_segment_state_controller` | `NetworkSegmentStateControllerConfig` | *(see below)* | `networking` | Network segment state controller timing. | diff --git a/crates/api-core/src/cfg/file.rs b/crates/api-core/src/cfg/file.rs index 0b747f34a4..ca602339d7 100644 --- a/crates/api-core/src/cfg/file.rs +++ b/crates/api-core/src/cfg/file.rs @@ -342,7 +342,7 @@ pub struct CarbideConfig { #[serde(default)] pub attestation_enabled: bool, - /// Site-wide enable for passive BMC credential rotation (REQ-2). When + /// Site-wide enable for passive BMC credential rotation. When /// `false` (the default), a Ready host never enters `RotatingBmc` on its own /// even if a device lags the staged site-wide target. This is the fleet /// kill-switch for rolling the feature out site-by-site; the operator diff --git a/crates/api-core/src/handlers/uefi.rs b/crates/api-core/src/handlers/uefi.rs index bc24502611..0d90ef5fe9 100644 --- a/crates/api-core/src/handlers/uefi.rs +++ b/crates/api-core/src/handlers/uefi.rs @@ -146,6 +146,42 @@ pub(crate) async fn host_uefi_clear_credential_key( Ok(CredentialKey::host_uefi_site_default(version)) } +/// The current site-wide DPU UEFI target version a device should be driven to, +/// from `sitewide_credential_rotation.target_version`. Mirrors +/// [`host_uefi_target_version`] for the `dpu_uefi` family: version 0 is the +/// legacy unversioned site-default baseline and a *missing* row is an error, +/// since the backfill migration seeds a `dpu_uefi` row on every site. +async fn dpu_uefi_target_version(conn: &mut sqlx::PgConnection) -> Result { + let version = db::credential_rotation::current_target_version( + conn, + db::credential_rotation::CredentialRotationType::DpuUefi, + ) + .await? + .ok_or_else(|| db::DatabaseError::Internal { + message: "no site-wide dpu_uefi rotation target row exists; the backfill migration \ + seeds one for every active credential type, so a missing row indicates a \ + broken or unmigrated database" + .to_string(), + })?; + u32::try_from(version).map_err(|e| db::DatabaseError::Internal { + message: format!("dpu UEFI target_version {version} is out of range for u32: {e}"), + }) +} + +/// The `CredentialKey` for the site-wide DPU UEFI password to *set* on a device: +/// the secret at the current `dpu_uefi` target version (table-driven; v0 = the +/// legacy unversioned site-default). The DPU analogue of +/// [`host_uefi_set_credential_key`]; only the database half (reads the version +/// and returns the key), so no connection is held across the remote reader. +pub(crate) async fn dpu_uefi_set_credential_key( + conn: &mut sqlx::PgConnection, +) -> Result { + let version = dpu_uefi_target_version(conn).await.map_err(|e| { + CarbideError::internal(format!("failed to read dpu UEFI target version: {e}")) + })?; + Ok(CredentialKey::dpu_uefi_site_default(version)) +} + pub(crate) async fn clear_host_uefi_password( api: &Api, request: Request, @@ -425,3 +461,148 @@ pub(crate) async fn set_host_uefi_password( Ok(Response::new(rpc::SetHostUefiPasswordResponse { job_id })) } + +/// Set a DPU's UEFI password directly on the device (the DPU equivalent of +/// [`set_host_uefi_password`]): stage the site-wide `dpu_uefi` credential through +/// the DPU's Redfish BIOS settings and record `dpu_uefi` convergence keyed by the +/// DPU BMC MAC. Like the host path, this stages the change and returns without +/// rebooting -- a DPU UEFI change only takes effect after a DPU restart, which +/// the DPU ingestion flow and the `RotatingDpuUefi` rotation state perform; this +/// direct path exists for operator testing, mirroring `SetHostUefiPassword`. +pub(crate) async fn set_dpu_uefi_password( + api: &Api, + request: Request, +) -> Result, Status> { + log_request_data(&request); + + let mut txn = api.txn_begin().await?; + + let request = request.into_inner(); + + let machine_id = if let Some(query) = request.machine_query { + match db::machine::find_by_query(&mut txn, &query).await? { + Some(machine) => { + log_machine_id(&machine.id); + machine.id + } + None => { + return Err(CarbideError::NotFoundError { + kind: "machine", + id: query, + } + .into()); + } + } + } else { + convert_and_log_machine_id(request.dpu_id.as_ref())? + }; + + if !machine_id.machine_type().is_dpu() { + return Err(CarbideError::InvalidArgument( + "SetDpuUefiPassword targets a DPU machine; use SetHostUefiPassword for a host".into(), + ) + .into()); + } + + let snapshot = db::managed_host::load_snapshot( + &mut txn, + &machine_id, + LoadSnapshotOptions { + include_history: false, + include_instance_data: false, + host_health_config: api.runtime_config.host_health, + }, + ) + .await? + .ok_or_else(|| CarbideError::NotFoundError { + kind: "machine", + id: machine_id.to_string(), + })?; + + // The loaded snapshot is keyed by the host machine; the DPU we are targeting + // is one of its `dpu_snapshots`. Locate it so we drive the DPU's own BMC. + let dpu = snapshot + .dpu_snapshots + .iter() + .find(|d| d.id == machine_id) + .ok_or_else(|| CarbideError::NotFoundError { + kind: "dpu", + id: machine_id.to_string(), + })?; + + let addr = dpu.bmc_addr().ok_or_else(|| { + CarbideError::InvalidArgument("specified DPU does not have BMC address".into()) + })?; + + // A known DPU BMC MAC is a hard precondition: it keys the dpu_uefi rotation + // bookkeeping recorded below, so reject up front rather than driving the + // device and only then discovering we cannot track its convergence. + let dpu_bmc_mac = dpu.status.bmc_info.mac.ok_or_else(|| { + CarbideError::InvalidArgument("specified DPU does not have a known BMC MAC address".into()) + })?; + + let bmc_access_info = + db::machine_interface::lookup_bmc_access_info(&mut txn, addr.ip(), Some(addr.port())) + .await?; + + // Resolve the site-wide DPU UEFI credential key to set (table-driven; v0 = + // the legacy unversioned site-default). This is the DB half; do it while the + // txn is open. + let dpu_uefi_key = dpu_uefi_set_credential_key(&mut txn).await?; + + // Commit before the remote reader (Vault) request and the redfish call so the + // connection is not held across them, then read the actual secret. + txn.commit().await?; + let dpu_uefi_credentials = + read_uefi_credentials(api.redfish_pool.credential_reader(), &dpu_uefi_key).await?; + + let redfish_client = api + .redfish_pool + .client_by_info(&bmc_access_info) + .await + .map_err(|e| { + tracing::error!(error = %e, "unable to create redfish client"); + CarbideError::RedfishClientCreation { + inner: e.into(), + machine_id, + } + })?; + + // A DPU stages the UEFI change through Redfish BIOS settings and schedules no + // job (it commits on the next DPU restart), so there is no job id to return. + api.redfish_pool + .uefi_setup(redfish_client.as_ref(), true, dpu_uefi_credentials) + .await + .map_err(|e| { + tracing::error!(error = %e, "Failed to run uefi_setup call for DPU"); + CarbideError::internal(format!("failed redfish uefi_setup subtask: {e}")) + })?; + + // Mirror the host path's optimistic convergence record: the change is staged + // through Redfish BIOS settings and commits on the next DPU restart; record + // dpu_uefi convergence (keyed by the DPU BMC MAC, as ingestion and the + // backfill do) so the rotation bookkeeping tracks this DPU. If the staged + // change ultimately fails to apply, this is inaccurate -- the same + // optimism the host set path carries. + api.with_txn(|txn| { + async move { + db::credential_rotation::record_device_converged( + txn, + dpu_bmc_mac, + db::credential_rotation::CredentialRotationType::DpuUefi, + ) + .await?; + Ok::<(), db::DatabaseError>(()) + } + .boxed() + }) + .await? + .map_err(|e| { + tracing::error!(error = %e, "Failed to record dpu_uefi convergence"); + CarbideError::Internal { + message: format!("Failed to record DPU UEFI convergence: {e}"), + } + })?; + + Ok(Response::new(rpc::SetDpuUefiPasswordResponse {})) +} diff --git a/crates/api-core/src/handlers/uefi_credential_rotation.rs b/crates/api-core/src/handlers/uefi_credential_rotation.rs index 25bdc5e494..c149956cd1 100644 --- a/crates/api-core/src/handlers/uefi_credential_rotation.rs +++ b/crates/api-core/src/handlers/uefi_credential_rotation.rs @@ -33,9 +33,10 @@ use crate::api::{Api, log_machine_id, log_request_data}; /// its next sweep; this handler only writes the flag (it performs no Redfish /// work itself). /// -/// Unlike a BMC, a UEFI credential only ever belongs to a machine (a host, or a -/// DPU once DPU UEFI rotation ships), never a switch or power shelf, so the -/// target is always a single machine id. +/// Unlike a BMC, a UEFI credential only ever belongs to a machine (a host or a +/// DPU -- both are machine rows), never a switch or power shelf, so the target +/// is always a single machine id. A DPU is addressed by its own `machine_id` or +/// its DPU BMC MAC, driving `RotatingDpuUefi`; a host drives `RotatingHostUefi`. pub(crate) async fn trigger_uefi_credential_rotation( api: &Api, request: Request, @@ -89,10 +90,12 @@ async fn resolve_target( .transpose()?; // A MAC uniquely names the BMC of one machine; resolve which machine owns - // it. UEFI rotation is keyed by the BMC MAC (host UEFI by the host BMC MAC; + // it. UEFI rotation is keyed by the BMC MAC (host UEFI by the host BMC MAC, // DPU UEFI by the DPU BMC MAC), so the machine resolver's BMC-MAC lookup is - // the right one -- and unlike a bare BMC credential, a UEFI credential only - // ever belongs to a machine, never a switch or power shelf. + // the right one for either -- `find_machine_id_by_bmc_mac` matches any + // machine's BMC interface, DPU rows included -- and unlike a bare BMC + // credential, a UEFI credential only ever belongs to a machine, never a + // switch or power shelf. let mac_machine_id = match bmc_mac { Some(mac) => Some( db::machine_topology::find_machine_id_by_bmc_mac(txn, mac) diff --git a/crates/api-core/src/setup.rs b/crates/api-core/src/setup.rs index c11164c7b2..0f3a32e429 100644 --- a/crates/api-core/src/setup.rs +++ b/crates/api-core/src/setup.rs @@ -1333,9 +1333,12 @@ async fn initialize_and_start_controllers<'a>( bmc_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::Bmc, ), - uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + host_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::HostUefi, ), + dpu_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + db::credential_rotation::CredentialRotationType::DpuUefi, + ), per_object_metrics_registry: per_object_metrics_registry.clone(), per_object_info: machine_per_object_info, } diff --git a/crates/api-core/src/tests/common/api_fixtures/mod.rs b/crates/api-core/src/tests/common/api_fixtures/mod.rs index c81784d973..17050bf979 100644 --- a/crates/api-core/src/tests/common/api_fixtures/mod.rs +++ b/crates/api-core/src/tests/common/api_fixtures/mod.rs @@ -338,9 +338,12 @@ impl TestEnv { bmc_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::Bmc, ), - uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + host_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::HostUefi, ), + dpu_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + db::credential_rotation::CredentialRotationType::DpuUefi, + ), per_object_metrics_registry: self.per_object_metrics_registry(), per_object_info: None, } @@ -454,6 +457,7 @@ impl TestEnv { ManagedHostState::HostReprovision { .. } => state.clone(), ManagedHostState::RotatingBmc { .. } => state.clone(), ManagedHostState::RotatingHostUefi { .. } => state.clone(), + ManagedHostState::RotatingDpuUefi { .. } => state.clone(), ManagedHostState::BomValidating { .. } => state.clone(), ManagedHostState::Validation { validation_state } => match validation_state { ValidationState::MachineValidation { machine_validation } => { @@ -1566,9 +1570,12 @@ pub async fn create_test_env_with_overrides( bmc_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::Bmc, ), - uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + host_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::HostUefi, ), + dpu_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + db::credential_rotation::CredentialRotationType::DpuUefi, + ), per_object_metrics_registry: per_object_metrics_registry.clone(), per_object_info: None, } diff --git a/crates/api-core/src/tests/power_shelf_state_controller/bmc_rotation.rs b/crates/api-core/src/tests/power_shelf_state_controller/bmc_rotation.rs index 5bc1174502..e7e55af4fd 100644 --- a/crates/api-core/src/tests/power_shelf_state_controller/bmc_rotation.rs +++ b/crates/api-core/src/tests/power_shelf_state_controller/bmc_rotation.rs @@ -15,8 +15,8 @@ * limitations under the License. */ -//! End-to-end coverage for power-shelf-controller BMC (PMC) credential rotation -//! (REQ-2): with the site-wide flag enabled, a staged target drives a Ready +//! End-to-end coverage for power-shelf-controller BMC (PMC) credential rotation: +//! with the site-wide flag enabled, a staged target drives a Ready //! power shelf through `PowerShelfControllerState::RotatingBmc` and back to //! Ready, converging the device and persisting the rotated per-device secret. //! Mirrors the switch-controller integration test diff --git a/crates/api-core/src/tests/switch_state_controller/bmc_rotation.rs b/crates/api-core/src/tests/switch_state_controller/bmc_rotation.rs index d5d1970564..30121b56c9 100644 --- a/crates/api-core/src/tests/switch_state_controller/bmc_rotation.rs +++ b/crates/api-core/src/tests/switch_state_controller/bmc_rotation.rs @@ -15,7 +15,7 @@ * limitations under the License. */ -//! End-to-end coverage for switch-controller BMC credential rotation (REQ-2): +//! End-to-end coverage for switch-controller BMC credential rotation: //! with the site-wide flag enabled, a staged target drives a Ready switch //! through `SwitchControllerState::RotatingBmc` and back to Ready, converging //! the device and persisting the rotated per-device secret. Mirrors the diff --git a/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql b/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql index c67190adca..bb91397293 100644 --- a/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql +++ b/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql @@ -1,6 +1,6 @@ -- Add bmc_credential_rotation_requested column to machines table. -- bmc_credential_rotation_requested: an operator "force-converge this BMC now" --- escape hatch (REQ-2). Set on the machine that owns the BMC (a host machine for +-- escape hatch. Set on the machine that owns the BMC (a host machine for -- its host BMC, a DPU machine for its DPU BMC). When true, the machine state -- controller enters RotatingBmc for the managed host and force-converges that -- machine's single BMC, bypassing the passive site-wide gate and the device's diff --git a/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql b/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql index 714a6ebde7..dfa4d0afb1 100644 --- a/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql +++ b/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql @@ -1,6 +1,6 @@ -- Add bmc_credential_rotation_requested column to switches table. -- bmc_credential_rotation_requested: an operator "force-converge this BMC now" --- escape hatch (REQ-2), the switch analogue of +-- escape hatch, the switch analogue of -- machines.bmc_credential_rotation_requested. When true, the switch state -- controller enters RotatingBmc and force-converges the switch BMC, bypassing -- the passive site-wide gate and the device's backoff quarantine. A switch has diff --git a/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql b/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql index 431b25d9d0..04afb6c4a4 100644 --- a/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql +++ b/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql @@ -1,6 +1,6 @@ -- Add bmc_credential_rotation_requested column to power_shelves table. -- bmc_credential_rotation_requested: an operator "force-converge this PMC now" --- escape hatch (REQ-2), the power-shelf analogue of +-- escape hatch, the power-shelf analogue of -- machines.bmc_credential_rotation_requested and -- switches.bmc_credential_rotation_requested. When true, the power-shelf state -- controller enters RotatingBmc and force-converges the power shelf BMC (PMC), diff --git a/crates/api-db/src/power_shelf.rs b/crates/api-db/src/power_shelf.rs index 8c87191171..2c6474ea59 100644 --- a/crates/api-db/src/power_shelf.rs +++ b/crates/api-db/src/power_shelf.rs @@ -353,7 +353,7 @@ pub async fn clear_power_shelf_maintenance_requested( } /// Record an operator force-converge request against a power shelf's BMC (PMC) -/// (REQ-2). The power-shelf state controller consumes it on its next sweep. +///. The power-shelf state controller consumes it on its next sweep. /// Mirrors [`crate::switch::set_bmc_credential_rotation_requested`]. pub async fn set_bmc_credential_rotation_requested( txn: &mut PgConnection, @@ -376,7 +376,7 @@ pub async fn set_bmc_credential_rotation_requested( Ok(()) } -/// Clear a power shelf's force-converge request (REQ-2), committed with the +/// Clear a power shelf's force-converge request, committed with the /// return to `Ready` once a forced tick settles. Mirrors /// [`crate::switch::clear_bmc_credential_rotation_requested`]. pub async fn clear_bmc_credential_rotation_requested( diff --git a/crates/api-db/src/switch.rs b/crates/api-db/src/switch.rs index 63803c5cf8..90fcb6a119 100644 --- a/crates/api-db/src/switch.rs +++ b/crates/api-db/src/switch.rs @@ -612,7 +612,7 @@ pub async fn find_switch_id_by_bmc_mac( .map_err(|e| DatabaseError::new("switch::find_switch_id_by_bmc_mac", e)) } -/// Record an operator force-converge request against a switch's BMC (REQ-2). The +/// Record an operator force-converge request against a switch's BMC. The /// switch state controller consumes it on its next sweep. Mirrors /// [`crate::machine::set_bmc_credential_rotation_requested`]. pub async fn set_bmc_credential_rotation_requested( @@ -637,7 +637,7 @@ pub async fn set_bmc_credential_rotation_requested( Ok(()) } -/// Clear a switch's force-converge request (REQ-2), committed with the return to +/// Clear a switch's force-converge request, committed with the return to /// `Ready` once a forced tick settles. Mirrors /// [`crate::machine::clear_bmc_credential_rotation_requested`]. pub async fn clear_bmc_credential_rotation_requested( @@ -1201,7 +1201,7 @@ mod tests { Ok(()) } - /// The force-converge escape hatch (REQ-2): a switch's BMC MAC resolves back + /// The force-converge escape hatch: a switch's BMC MAC resolves back /// to its id, the boolean flag round-trips through the load path, and both /// mutating DAOs surface a clean not-found for an unknown switch. #[crate::sqlx_test] diff --git a/crates/api-model/src/machine/mod.rs b/crates/api-model/src/machine/mod.rs index 132542b9c3..0fa282a6c4 100644 --- a/crates/api-model/src/machine/mod.rs +++ b/crates/api-model/src/machine/mod.rs @@ -833,7 +833,7 @@ pub struct Machine { /// [`ManagedHostState::Maintenance`] to execute the requested operation. pub machine_maintenance_requested: Option, - /// Operator "force-converge this BMC now" request (REQ-2). Set on the machine + /// Operator "force-converge this BMC now" request. Set on the machine /// that owns the BMC (a host machine for its host BMC, a DPU machine for its /// DPU BMC). When `true`, the machine state controller enters `RotatingBmc` /// and force-converges this machine's single BMC on its next sweep, @@ -1288,7 +1288,7 @@ pub enum ManagedHostState { }, /// The host and/or its DPUs are converging their BMC root credential to the - /// staged site-wide rotation target (REQ-2). A pool-only, top-level state: + /// staged site-wide rotation target. A pool-only, top-level state: /// it blocks instance creation (which requires exact `Ready`) for the bounded /// duration of the rotation. Per-device backoff/quarantine is owned by the /// rotation engine's `device_credential_rotation` bookkeeping, so this state @@ -1318,6 +1318,28 @@ pub enum ManagedHostState { uefi_setup_info: UefiSetupInfo, }, + /// One of the host's DPUs is converging its own UEFI (BIOS setup) password + /// to the staged site-wide `dpu_uefi` rotation target. A + /// pool-only, top-level state (same instance-creation block as + /// `RotatingHostUefi`), but keyed to a single DPU: applying a DPU UEFI + /// password stages a `Bios/Settings` change and commits it with a DPU + /// restart (distinct from a host power-cycle), so the reboot is scoped to + /// that DPU. Because a host can carry several DPUs, this state names the + /// `dpu_machine_id` it is converging and processes one DPU per + /// `Ready -> RotatingDpuUefi -> Ready` cycle; the Ready entry guard + /// re-selects the next lagging or force-requested DPU on a later sweep. + /// + /// Unlike the host's multi-tick `RotatingHostUefi`, a DPU UEFI change is + /// applied in a single tick -- stage the `Bios/Settings` change, issue the + /// DPU restart that commits it, then record convergence -- so this state + /// carries no [`UefiSetupInfo`] sub-state: it names only the DPU it targets + /// and re-runs idempotently if the controller restarts mid-tick. Per-device + /// backoff/quarantine is the rotation engine's `device_credential_rotation` + /// bookkeeping keyed by that DPU's BMC MAC. + RotatingDpuUefi { + dpu_machine_id: MachineId, + }, + /// State used to indicate the API is currently waiting on the /// machine to send attestation measurements, or waiting for /// measurements to match a valid/approved measurement bundle, @@ -2602,6 +2624,9 @@ impl Display for ManagedHostState { ManagedHostState::RotatingHostUefi { uefi_setup_info } => { write!(f, "RotatingHostUefi/{:?}", uefi_setup_info.uefi_setup_state) } + ManagedHostState::RotatingDpuUefi { dpu_machine_id } => { + write!(f, "RotatingDpuUefi/{dpu_machine_id}") + } ManagedHostState::Measuring { measuring_state } => { write!(f, "Measuring/{measuring_state}") } @@ -2704,6 +2729,7 @@ impl ManagedHostState { } ManagedHostState::RotatingBmc { .. } => "RotatingBmc".to_string(), ManagedHostState::RotatingHostUefi { .. } => "RotatingHostUefi".to_string(), + ManagedHostState::RotatingDpuUefi { .. } => "RotatingDpuUefi".to_string(), ManagedHostState::Measuring { measuring_state } => { format!("Measuring/{measuring_state}") } @@ -2917,6 +2943,9 @@ pub fn state_sla( ManagedHostState::RotatingHostUefi { .. } => { StateSla::with_sla(slas::ROTATING_HOST_UEFI, time_in_state) } + ManagedHostState::RotatingDpuUefi { .. } => { + StateSla::with_sla(slas::ROTATING_DPU_UEFI, time_in_state) + } ManagedHostState::Measuring { measuring_state } => match measuring_state { // The API shouldn't be waiting for measurements for long. As soon // as it transitions into this state, Scout should get an Action::Measure diff --git a/crates/api-model/src/machine/slas.rs b/crates/api-model/src/machine/slas.rs index 91fb6c8685..8e2dddbe76 100644 --- a/crates/api-model/src/machine/slas.rs +++ b/crates/api-model/src/machine/slas.rs @@ -63,7 +63,7 @@ pub const VALIDATION: Duration = Duration::from_secs(30 * 60); pub const MAINTENANCE: Duration = Duration::from_secs(5 * 60); -// BMC credential rotation (REQ-2). A single synchronous Redfish password change +// BMC credential rotation. A single synchronous Redfish password change // per device (host + each DPU); generous enough to absorb a slow BMC plus the // engine's short per-device backoff without tripping the SLA on the first retry. pub const ROTATING_BMC: Duration = Duration::from_secs(15 * 60); @@ -75,6 +75,14 @@ pub const ROTATING_BMC: Duration = Duration::from_secs(15 * 60); // tripping the SLA on the first retry. pub const ROTATING_HOST_UEFI: Duration = Duration::from_secs(40 * 60); +// DPU UEFI credential rotation. Applying a new DPU UEFI password +// stages a Bios/Settings change and commits it with a DPU restart (scoped to the +// DPU, not a full host power-cycle). One DPU is converged per cycle, so the +// budget mirrors the host UEFI rotation: enough to absorb a slow DPU restart plus +// the engine's short per-device backoff without tripping the SLA on the first +// retry. +pub const ROTATING_DPU_UEFI: Duration = Duration::from_secs(40 * 60); + /// Configuration for machine state SLA durations. #[derive(Clone, Debug, PartialEq)] pub struct MachineSlaConfig { diff --git a/crates/api-model/src/power_shelf/mod.rs b/crates/api-model/src/power_shelf/mod.rs index fc88756e80..691ae6d0fb 100644 --- a/crates/api-model/src/power_shelf/mod.rs +++ b/crates/api-model/src/power_shelf/mod.rs @@ -74,7 +74,7 @@ pub struct PowerShelf { pub bmc_mac_address: Option, - /// Operator "force-converge this power shelf PMC now" request (REQ-2). When + /// Operator "force-converge this power shelf PMC now" request. When /// `true`, the power-shelf state controller enters `RotatingBmc` and /// force-converges the PMC on its next sweep, bypassing the passive /// site-wide gate and the device's backoff quarantine. A power shelf has @@ -247,7 +247,7 @@ pub enum PowerShelfControllerState { Ready, /// The PowerShelf's BMC (PMC) credential is being converged to the staged - /// site-wide rotation target (REQ-2), entered from `Ready` at lowest + /// site-wide rotation target, entered from `Ready` at lowest /// precedence. The shared engine owns crash-safety and per-device backoff, /// so this state carries only a retry budget for transient handler failures. RotatingBmc { diff --git a/crates/api-model/src/switch/mod.rs b/crates/api-model/src/switch/mod.rs index 92beacf196..2ce9f8efed 100644 --- a/crates/api-model/src/switch/mod.rs +++ b/crates/api-model/src/switch/mod.rs @@ -169,7 +169,7 @@ pub struct Switch { /// without re-resolving. `None` when no BMC interface is linked yet. pub bmc_info: Option, - /// Operator "force-converge this switch BMC now" request (REQ-2). When + /// Operator "force-converge this switch BMC now" request. When /// `true`, the switch state controller enters `RotatingBmc` and /// force-converges the BMC on its next sweep, bypassing the passive /// site-wide gate and the device's backoff quarantine. A switch has exactly @@ -374,7 +374,7 @@ pub enum SwitchControllerState { Ready, /// The Switch is converging its BMC credentials to the staged site-wide - /// rotation target (REQ-2). Entered from `Ready` (lowest precedence) when + /// rotation target. Entered from `Ready` (lowest precedence) when /// the switch BMC lags the target and site-wide rotation is enabled, or when /// an operator force-converge request is pending; a BMC password change /// never touches the switch data plane, so this is safe in `Ready`. The diff --git a/crates/machine-controller/src/config/mod.rs b/crates/machine-controller/src/config/mod.rs index 4d37b3e1c2..1e4b25d45f 100644 --- a/crates/machine-controller/src/config/mod.rs +++ b/crates/machine-controller/src/config/mod.rs @@ -52,9 +52,11 @@ pub struct MachineStateHandlerSiteConfig { /// force-converge escape hatch still works regardless. pub bmc_rotation_enabled: bool, - /// Site-wide kill-switch for the passive UEFI credential rotation guard. When - /// `false`, a Ready host never enters `RotatingHostUefi` on its own; the operator - /// force-converge escape hatch still works regardless. + /// Site-wide kill-switch for the passive UEFI credential rotation guard, + /// covering both host and DPU UEFI. When `false`, a Ready host never enters + /// `RotatingHostUefi` (nor drives a DPU into `RotatingDpuUefi`) on its own; + /// the per-machine operator force-converge escape hatch still works + /// regardless, for the host or an individual DPU. pub uefi_rotation_enabled: bool, pub dpu_enable_secure_boot: bool, diff --git a/crates/machine-controller/src/context.rs b/crates/machine-controller/src/context.rs index bb8193cead..c92550e192 100644 --- a/crates/machine-controller/src/context.rs +++ b/crates/machine-controller/src/context.rs @@ -62,7 +62,12 @@ pub struct MachineStateHandlerServices { /// Short-TTL cache of the site-wide host-UEFI rotation aggregate, shared /// across this replica's per-object ticks. Family-scoped and separate from /// `bmc_rotation_gate` so a UEFI sweep never consults BMC counts. - pub uefi_rotation_gate: RotationGate, + pub host_uefi_rotation_gate: RotationGate, + /// Short-TTL cache of the site-wide DPU-UEFI rotation aggregate, shared + /// across this replica's per-object ticks. A `RotationGate` is single-family, + /// so DPU UEFI gets its own gate separate from `host_uefi_rotation_gate`: a + /// DPU sweep queries only `dpu_uefi` counts, keyed by each DPU's BMC MAC. + pub dpu_uefi_rotation_gate: RotationGate, /// Shared registry backing the generic per-object health metrics. pub per_object_metrics_registry: Arc, /// Trait/association info gauges for the per-object metrics endpoint, diff --git a/crates/machine-controller/src/handler.rs b/crates/machine-controller/src/handler.rs index 8627f8e16f..562cf81847 100644 --- a/crates/machine-controller/src/handler.rs +++ b/crates/machine-controller/src/handler.rs @@ -120,6 +120,7 @@ use crate::{MeasuringOutcome, get_measuring_prerequisites, handle_measuring_stat pub mod attestation; mod bios_config; mod dpf; +mod dpu_uefi_rotation; mod firmware_artifact; mod helpers; mod host_boot_config; @@ -1104,6 +1105,20 @@ impl MachineStateHandler { )); } + // Same lowest-precedence idle-only rule again, for each DPU's + // UEFI password. A DPU change stages a Bios/Settings write and + // commits it with a DPU restart, so it gets its own state keyed + // to one DPU; the guard selects the next lagging or + // force-requested DPU and the next sweep re-selects any others. + if let Some(dpu_machine_id) = + dpu_uefi_rotation::select_dpu_for_uefi_rotation(ctx.services, mh_snapshot) + .await? + { + return Ok(StateHandlerOutcome::transition( + ManagedHostState::RotatingDpuUefi { dpu_machine_id }, + )); + } + Ok(StateHandlerOutcome::do_nothing()) } @@ -1162,6 +1177,10 @@ impl MachineStateHandler { .await } + ManagedHostState::RotatingDpuUefi { dpu_machine_id } => { + dpu_uefi_rotation::handle_rotating_dpu_uefi(ctx, mh_snapshot, *dpu_machine_id).await + } + ManagedHostState::Assigned { instance_state: _ } => { // Process changes needed for instance. self.instance_handler diff --git a/crates/machine-controller/src/handler/dpu_uefi_rotation.rs b/crates/machine-controller/src/handler/dpu_uefi_rotation.rs new file mode 100644 index 0000000000..c1c38e8262 --- /dev/null +++ b/crates/machine-controller/src/handler/dpu_uefi_rotation.rs @@ -0,0 +1,463 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//! Machine-controller DPU UEFI credential rotation. +//! +//! The DPU sibling of [`super::host_uefi_rotation`]. A DPU's UEFI password is a +//! distinct device from its host's: it is keyed by the *DPU* BMC MAC, applied +//! through a DPU restart (not a host power-cycle), and a host can carry several +//! DPUs. So DPU UEFI convergence gets its own [`RotatingDpuUefi`] state +//! ([`handle_rotating_dpu_uefi`]) that converges *one* DPU per +//! `Ready -> RotatingDpuUefi -> Ready` cycle; this module is the thin +//! policy/bookkeeping adapter around that FSM: +//! +//! - *Which DPU (if any) should rotate now?* [`select_dpu_for_uefi_rotation`] +//! returns the first DPU that is force-requested (operator escape hatch, +//! honored even when the site flag is off) or -- when UEFI rotation is enabled +//! site-wide -- lags the staged `dpu_uefi` target. A DPU with no +//! `device_credential_rotation` row (never set) is skipped by the passive gate +//! exactly as a never-set host is, since [`RotationGate::rotation_needed`] +//! reports no work for a missing row; a force request still selects it. +//! - *What credential authenticates the change?* +//! [`dpu_uefi_current_candidates`] resolves the ordered, versioned +//! current-password candidates -- the DPU analogue of the host candidate walk, +//! ending in the DPU factory default rather than the empty string. +//! +//! [`RotatingDpuUefi`]: model::machine::ManagedHostState::RotatingDpuUefi +//! [`RotationGate::rotation_needed`]: carbide_credential_rotation::RotationGate::rotation_needed + +use bmc_vendor::DpuModel; +use carbide_secrets::credentials::{CredentialKey, CredentialReader, CredentialType, Credentials}; +use carbide_uuid::machine::MachineId; +use eyre::eyre; +use model::machine::{Machine, ManagedHostState, ManagedHostStateSnapshot}; +use state_controller::state_handler::{ + StateHandlerContext, StateHandlerError, StateHandlerOutcome, +}; + +use super::{current_site_uefi_target, handler_restart_dpu, resolve_site_uefi_credentials}; +use crate::context::{MachineStateHandlerContextObjects, MachineStateHandlerServices}; + +/// `true` when this DPU's UEFI credential lags the staged site-wide `dpu_uefi` +/// target and is not quarantined. A DPU with no BMC MAC (untrackable) or no +/// rotation row (never set) yields `false`. +async fn dpu_uefi_rotation_needed( + services: &MachineStateHandlerServices, + dpu: &Machine, +) -> Result { + let Some(mac) = dpu.status.bmc_info.mac else { + return Ok(false); + }; + services + .dpu_uefi_rotation_gate + .rotation_needed(&services.db_pool, mac) + .await + .map_err(|e| { + StateHandlerError::GenericError(eyre::eyre!("dpu uefi rotation gate query: {e}")) + }) +} + +/// Whether this DPU should enter `RotatingDpuUefi` now. An operator +/// force-converge request always wins -- honored even when the site-wide flag is +/// off. Otherwise the passive gate fires only when UEFI rotation is enabled +/// site-wide *and* the DPU lags the staged target; the cheap flag is checked +/// first so a disabled site never runs the gate query. +async fn should_rotate_dpu_uefi( + services: &MachineStateHandlerServices, + dpu: &Machine, +) -> Result { + if dpu.uefi_credential_rotation_requested { + return Ok(true); + } + Ok(services.site_config.uefi_rotation_enabled + && dpu_uefi_rotation_needed(services, dpu).await?) +} + +/// Select the DPU (if any) a Ready host should converge this cycle, in +/// `dpu_snapshots` order: the first DPU that is force-requested or (with UEFI +/// rotation enabled site-wide) lags the staged `dpu_uefi` target. Returns the +/// DPU's machine id, which `RotatingDpuUefi` carries to key the reboot FSM to +/// that one DPU; the remaining DPUs are re-selected on later sweeps, one per +/// `Ready -> RotatingDpuUefi -> Ready` cycle. +pub(crate) async fn select_dpu_for_uefi_rotation( + services: &MachineStateHandlerServices, + mh: &ManagedHostStateSnapshot, +) -> Result, StateHandlerError> { + for dpu in &mh.dpu_snapshots { + if should_rotate_dpu_uefi(services, dpu).await? { + return Ok(Some(dpu.id)); + } + } + Ok(None) +} + +/// Ordered current-password candidates for a DPU UEFI rotation, most-likely +/// first: the secret at the device's tracked current version, then the target +/// version (covers an already-applied-but-unrecorded rotation), then the DPU +/// factory default. The first that authenticates the change wins. This is the +/// DPU analogue of the host candidate walk, differing only in the terminal +/// fallback: a never-rotated DPU still carries its hardware factory password +/// (e.g. "bluefield"), not the empty string a factory-reset host carries. +pub(crate) async fn dpu_uefi_current_candidates( + reader: &dyn CredentialReader, + current_version: Option, + target_version: u32, +) -> Result, StateHandlerError> { + let mut versions: Vec = Vec::new(); + if let Some(v) = current_version { + versions.push(v); + } + if !versions.contains(&target_version) { + versions.push(target_version); + } + + let mut candidates = Vec::with_capacity(versions.len() + 1); + for version in versions { + if let Some(password) = read_dpu_uefi_password(reader, version).await? { + candidates.push(password); + } + } + // Factory default last: a never-set DPU still holds its hardware password. + candidates.push(read_dpu_factory_default(reader).await?); + Ok(candidates) +} + +/// Read the site-wide DPU UEFI password at a specific version, or `None` if no +/// secret is staged for that version. +async fn read_dpu_uefi_password( + reader: &dyn CredentialReader, + version: u32, +) -> Result, StateHandlerError> { + let key = CredentialKey::dpu_uefi_site_default(version); + let credentials = reader.get_credentials(&key).await.map_err(|e| { + StateHandlerError::GenericError(eyre::eyre!( + "read site dpu UEFI credential {}: {e}", + key.to_key_str() + )) + })?; + Ok(credentials.map(|Credentials::UsernamePassword { password, .. }| password)) +} + +/// Read the DPU hardware factory-default UEFI password (a hardware constant, not +/// a versioned/site credential), falling back to the well-known "bluefield" +/// default when the store has no entry -- matching the ingestion `uefi_setup` +/// path so a never-set DPU authenticates identically whether it converges via +/// ingestion or via a forced rotation. +async fn read_dpu_factory_default( + reader: &dyn CredentialReader, +) -> Result { + let key = CredentialKey::DpuUefi { + credential_type: CredentialType::DpuHardwareDefault { + model: DpuModel::Unknown, + }, + }; + let credentials = reader.get_credentials(&key).await.map_err(|e| { + StateHandlerError::GenericError(eyre::eyre!( + "read dpu UEFI factory default {}: {e}", + key.to_key_str() + )) + })?; + Ok(credentials + .map(|Credentials::UsernamePassword { password, .. }| password) + .unwrap_or_else(|| "bluefield".to_string())) +} + +/// Converge one DPU's UEFI (BIOS setup) password to the staged site-wide +/// `dpu_uefi` target in `ManagedHostState::RotatingDpuUefi`, then return to +/// `Ready`. The Ready entry guard already picked `dpu_machine_id` as the DPU to +/// converge this cycle (force-requested, or lagging with rotation enabled). +/// +/// Single-tick, fire-and-record (matching the DPU ingestion path): stage the +/// target through the DPU's `Bios/Settings` (authenticating with the +/// current-version credential via [`dpu_uefi_current_candidates`], not the +/// empty/factory assumption), issue the DPU restart that commits it, then record +/// convergence. Crash-safe and idempotent -- `rotating_to_version` is staged +/// before the restart and re-running just re-applies the same target and +/// re-issues the restart. A device-level failure is quarantined with exponential +/// backoff and returns to `Ready`, so the DPU never wedges the host in this +/// state; the passive gate then skips the DPU until the window elapses. A +/// missing DPU (gone from the snapshot) or missing BMC MAC returns to `Ready` +/// without acting. +pub(crate) async fn handle_rotating_dpu_uefi( + ctx: &mut StateHandlerContext<'_, MachineStateHandlerContextObjects>, + state: &ManagedHostStateSnapshot, + dpu_machine_id: MachineId, +) -> Result, StateHandlerError> { + use db::credential_rotation::CredentialRotationType::DpuUefi; + + let db_pool = ctx.services.db_pool.clone(); + + // The entry guard selected this DPU from the same snapshot; if it is somehow + // gone now, there is nothing to converge -- return to Ready rather than error. + let Some(dpu) = state.dpu_snapshots.iter().find(|d| d.id == dpu_machine_id) else { + tracing::warn!( + %dpu_machine_id, + "RotatingDpuUefi selected a DPU no longer present on the host; returning to Ready" + ); + return Ok(StateHandlerOutcome::transition(ManagedHostState::Ready)); + }; + + // A known DPU BMC MAC keys the dpu_uefi rotation bookkeeping; without it the + // device can be neither tracked nor reached (the entry guard likewise never + // selects such a DPU). + let dpu_bmc_mac = dpu + .status + .bmc_info + .mac + .ok_or(StateHandlerError::MissingData { + object_id: dpu.id.to_string(), + missing: "bmc_mac", + })?; + let forced = dpu.uefi_credential_rotation_requested; + let dpf_used_for_ingestion = state.host_snapshot.config.dpf.used_for_ingestion; + + let target = current_site_uefi_target(&db_pool, DpuUefi).await?; + + // The device's tracked current version selects the first authentication + // candidate; its prior attempt count sizes the backoff on failure. + let (current_version, prior_attempts) = { + let mut conn = db_pool.acquire().await?; + match db::credential_rotation::device_rotation_status(&mut conn, DpuUefi, dpu_bmc_mac) + .await + .map_err(|e| { + StateHandlerError::GenericError(eyre!("read dpu uefi rotation status: {e}")) + })? { + Some(status) => ( + status.current_version.and_then(|v| u32::try_from(v).ok()), + status.rotate_attempts, + ), + None => (None, 0), + } + }; + + // Resolve the ordered current-password candidates and the new (target) + // password before touching the device; scope the credential reader so it is + // not held across the mutable-context DPU restart below. + let (candidates, new_password) = { + let reader = ctx.services.redfish_client_pool.credential_reader(); + let candidates = dpu_uefi_current_candidates(reader, current_version, target).await?; + let Credentials::UsernamePassword { + password: new_password, + .. + } = resolve_site_uefi_credentials(&db_pool, reader, DpuUefi).await?; + (candidates, new_password) + }; + + let dpu_redfish_client = ctx.services.create_redfish_client_from_machine(dpu).await?; + + // Stage the target before dispatch (crash-safe), in its own short + // transaction so no lock is held across the Redfish round-trip. + { + let mut conn = db_pool.acquire().await?; + db::credential_rotation::mark_device_rotating_to_version( + &mut conn, + dpu_bmc_mac, + DpuUefi, + target as i32, + ) + .await + .map_err(|e| { + StateHandlerError::GenericError(eyre!("stage dpu uefi rotating_to_version: {e}")) + })?; + } + + match ctx + .services + .redfish_client_pool + .rotate_uefi_password(dpu_redfish_client.as_ref(), &candidates, new_password) + .await + { + // The DPU stages the change through Bios/Settings and schedules no job + // (`job_id` is always `None`); the restart below commits it. + Ok(_job_id) => { + handler_restart_dpu(dpu, ctx, dpf_used_for_ingestion).await?; + + let mut txn = db_pool.begin().await?; + let promoted = db::credential_rotation::promote_rotating_to_current( + &mut txn, + dpu_bmc_mac, + DpuUefi, + ) + .await + .map_err(|e| { + StateHandlerError::GenericError(eyre!("promote dpu uefi rotating_to_version: {e}")) + })?; + if !promoted { + db::credential_rotation::record_device_converged(&mut txn, dpu_bmc_mac, DpuUefi) + .await + .map_err(|e| { + StateHandlerError::GenericError(eyre!("record dpu uefi convergence: {e}")) + })?; + } + tracing::info!(mac = %dpu_bmc_mac, %dpu_machine_id, "DPU UEFI converged to site-wide rotation target"); + // A forced attempt genuinely fired, so clear the one-shot request on + // the same transaction; a re-force is a fresh operator action. + if forced { + db::machine::clear_uefi_credential_rotation_requested(&mut txn, dpu_machine_id) + .await?; + } + Ok(StateHandlerOutcome::transition(ManagedHostState::Ready).with_txn(txn)) + } + Err(e) => { + // Device-level failure (all current-password candidates rejected, or + // the DPU refused the change). The pool already redacted the password + // out of the error. Quarantine with backoff and return to Ready so + // the host never wedges in this state. + let redacted = e.to_string(); + let quarantined_until = + db::credential_rotation::backoff_until(prior_attempts, chrono::Utc::now()); + let mut txn = db_pool.begin().await?; + db::credential_rotation::increment_rotate_attempt( + &mut txn, + dpu_bmc_mac, + DpuUefi, + &redacted, + quarantined_until, + ) + .await + .map_err(|e| { + StateHandlerError::GenericError(eyre!("record dpu uefi rotation failure: {e}")) + })?; + tracing::warn!( + mac = %dpu_bmc_mac, + %dpu_machine_id, + %quarantined_until, + error = %redacted, + "DPU UEFI rotation attempt failed; quarantined until backoff elapses" + ); + // A forced attempt genuinely fired, so clear the one-shot request on + // the same transaction; a re-force is a fresh operator action. + if forced { + db::machine::clear_uefi_credential_rotation_requested(&mut txn, dpu_machine_id) + .await?; + } + Ok(StateHandlerOutcome::transition(ManagedHostState::Ready).with_txn(txn)) + } + } +} + +#[cfg(test)] +mod tests { + use carbide_secrets::MemoryCredentialStore; + use carbide_secrets::credentials::CredentialWriter; + + use super::*; + + /// Seed a versioned DPU UEFI secret into an in-memory reader. + async fn seed_version(store: &MemoryCredentialStore, version: u32, password: &str) { + store + .set_credentials( + &CredentialKey::dpu_uefi_site_default(version), + &Credentials::UsernamePassword { + username: String::new(), + password: password.to_string(), + }, + ) + .await + .expect("seeding a dpu UEFI secret should succeed"); + } + + /// Seed the DPU hardware factory default into an in-memory reader. + async fn seed_factory_default(store: &MemoryCredentialStore, password: &str) { + store + .set_credentials( + &CredentialKey::DpuUefi { + credential_type: CredentialType::DpuHardwareDefault { + model: DpuModel::Unknown, + }, + }, + &Credentials::UsernamePassword { + username: String::new(), + password: password.to_string(), + }, + ) + .await + .expect("seeding the dpu UEFI factory default should succeed"); + } + + /// A tracked DPU lists its current-version secret first, then the target + /// version, then the factory default, so authentication tries the most + /// likely current password before falling back. + #[tokio::test] + async fn candidates_are_current_then_target_then_factory_default() { + let store = MemoryCredentialStore::default(); + seed_version(&store, 1, "current-v1").await; + seed_version(&store, 2, "target-v2").await; + seed_factory_default(&store, "bf-default").await; + + let candidates = dpu_uefi_current_candidates(&store, Some(1), 2) + .await + .expect("resolving candidates should succeed"); + + assert_eq!( + candidates, + vec![ + "current-v1".to_string(), + "target-v2".to_string(), + "bf-default".to_string(), + ], + ); + } + + /// A never-rotated DPU (no tracked current version) tries the target then + /// the factory default -- the first-rotation versioned-vs-factory case. + #[tokio::test] + async fn candidates_for_a_never_rotated_dpu_are_target_then_factory_default() { + let store = MemoryCredentialStore::default(); + seed_version(&store, 0, "legacy-v0").await; + seed_factory_default(&store, "bf-default").await; + + let candidates = dpu_uefi_current_candidates(&store, None, 0) + .await + .expect("resolving candidates should succeed"); + + assert_eq!( + candidates, + vec!["legacy-v0".to_string(), "bf-default".to_string()], + ); + } + + /// When current and target are the same version it is listed once, so we + /// never probe the same password twice. + #[tokio::test] + async fn candidates_dedupe_when_current_equals_target() { + let store = MemoryCredentialStore::default(); + seed_version(&store, 3, "v3").await; + seed_factory_default(&store, "bf-default").await; + + let candidates = dpu_uefi_current_candidates(&store, Some(3), 3) + .await + .expect("resolving candidates should succeed"); + + assert_eq!(candidates, vec!["v3".to_string(), "bf-default".to_string()],); + } + + /// With no factory-default secret staged, the walk falls back to the + /// well-known "bluefield" hardware default so a never-set DPU still has a + /// terminal candidate. + #[tokio::test] + async fn factory_default_falls_back_to_bluefield() { + let store = MemoryCredentialStore::default(); + seed_version(&store, 1, "v1").await; + + let candidates = dpu_uefi_current_candidates(&store, Some(1), 1) + .await + .expect("resolving candidates should succeed"); + + assert_eq!(candidates, vec!["v1".to_string(), "bluefield".to_string()]); + } +} diff --git a/crates/machine-controller/src/handler/host_boot_config.rs b/crates/machine-controller/src/handler/host_boot_config.rs index 894f0a8e40..61f0d162c1 100644 --- a/crates/machine-controller/src/handler/host_boot_config.rs +++ b/crates/machine-controller/src/handler/host_boot_config.rs @@ -558,9 +558,12 @@ mod tests { bmc_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::Bmc, ), - uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + host_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( db::credential_rotation::CredentialRotationType::HostUefi, ), + dpu_uefi_rotation_gate: carbide_credential_rotation::RotationGate::new_for_family( + db::credential_rotation::CredentialRotationType::DpuUefi, + ), }; let mut metrics = MachineMetrics::default(); let mut pending_db_writes = DbWriteBatch::new(); diff --git a/crates/machine-controller/src/handler/host_uefi_rotation.rs b/crates/machine-controller/src/handler/host_uefi_rotation.rs index 836f5d2714..696020fb72 100644 --- a/crates/machine-controller/src/handler/host_uefi_rotation.rs +++ b/crates/machine-controller/src/handler/host_uefi_rotation.rs @@ -99,7 +99,7 @@ pub(crate) async fn should_enter_host_uefi_rotation( // The gate reports `true` when the host UEFI credential lags the staged // site-wide target and is not quarantined. services - .uefi_rotation_gate + .host_uefi_rotation_gate .rotation_needed(&services.db_pool, mac) .await .map_err(|e| StateHandlerError::GenericError(eyre::eyre!("uefi rotation gate query: {e}"))) @@ -331,7 +331,7 @@ async fn set_rotating_host_uefi_password( match ctx .services .redfish_client_pool - .rotate_host_uefi_password(redfish_client, &candidates, new_password) + .rotate_uefi_password(redfish_client, &candidates, new_password) .await { Ok(job_id) => Ok(rotating_host_uefi_step( diff --git a/crates/machine-controller/src/handler/rotation.rs b/crates/machine-controller/src/handler/rotation.rs index d4fa3c9bfd..28e203a0b9 100644 --- a/crates/machine-controller/src/handler/rotation.rs +++ b/crates/machine-controller/src/handler/rotation.rs @@ -15,7 +15,7 @@ * limitations under the License. */ -//! Machine-controller BMC credential rotation (REQ-2). +//! Machine-controller BMC credential rotation. //! //! The shared [`carbide_credential_rotation`] engine owns the actual password //! dance, backoff, and crash-safety; this module is the thin machine-controller diff --git a/crates/machine-controller/src/io.rs b/crates/machine-controller/src/io.rs index ba3300dd21..ef2527269a 100644 --- a/crates/machine-controller/src/io.rs +++ b/crates/machine-controller/src/io.rs @@ -345,6 +345,7 @@ impl StateControllerIO for MachineStateControllerIO { ManagedHostState::HostReprovision { .. } => ("hostreprovisioning", ""), ManagedHostState::RotatingBmc { .. } => ("rotatingbmc", ""), ManagedHostState::RotatingHostUefi { .. } => ("rotatinghostuefi", ""), + ManagedHostState::RotatingDpuUefi { .. } => ("rotatingdpuuefi", ""), ManagedHostState::Measuring { measuring_state } => { ("measuring", measuring_state_name(measuring_state)) } diff --git a/crates/machine-controller/tests/integration/bmc_rotation.rs b/crates/machine-controller/tests/integration/bmc_rotation.rs index 709d25ba1e..6e23f21a86 100644 --- a/crates/machine-controller/tests/integration/bmc_rotation.rs +++ b/crates/machine-controller/tests/integration/bmc_rotation.rs @@ -15,7 +15,7 @@ * limitations under the License. */ -//! End-to-end coverage for machine-controller BMC credential rotation (REQ-2): +//! End-to-end coverage for machine-controller BMC credential rotation: //! a staged site-wide target drives a Ready host through //! `ManagedHostState::RotatingBmc` and back to Ready, converging the device and //! persisting the rotated per-device secret. diff --git a/crates/machine-controller/tests/integration/dpu_uefi_rotation.rs b/crates/machine-controller/tests/integration/dpu_uefi_rotation.rs new file mode 100644 index 0000000000..4157e07a5a --- /dev/null +++ b/crates/machine-controller/tests/integration/dpu_uefi_rotation.rs @@ -0,0 +1,380 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//! End-to-end coverage for machine-controller DPU UEFI credential rotation: +//! a staged site-wide `dpu_uefi` target drives a Ready host to +//! converge one of its DPUs through the single-tick +//! `ManagedHostState::RotatingDpuUefi` state (stage -> DPU restart -> record) and +//! back to Ready, converging that DPU's tracked UEFI version. The DPU is a +//! distinct device from its host, keyed by the DPU BMC MAC and applied via a DPU +//! restart, so these tests target the host's first DPU rather than the host +//! itself. As with the host sibling there is no per-device secret: the site-wide +//! versioned credential fully determines the password, so the assertions cover +//! the rotation bookkeeping (target/current version, convergence, quarantine). + +use std::sync::Arc; + +use carbide_secrets::credentials::{CredentialKey, Credentials}; +use carbide_secrets::test_support::credentials::TestCredentialManager; +use carbide_test_harness::prelude::*; +use carbide_test_harness::test_support::fixture_config::FixtureDefault as _; +use chrono::{Duration, Utc}; +use db::credential_rotation::{ + CredentialRotationType, device_rotation_status, increment_rotate_attempt, + record_device_converged, set_next_target_version, +}; +use mac_address::MacAddress; +use model::machine::ManagedHostState; +use model::test_support::ManagedHostConfig; + +use crate::env::Env; + +const DPU_UEFI: CredentialRotationType = CredentialRotationType::DpuUefi; + +/// The site-wide DPU UEFI secret at a version. DPU UEFI passwords are uniform per +/// version, so this (not a per-device key) is what the rotation resolves and +/// applies. +fn site_key(version: u32) -> CredentialKey { + CredentialKey::dpu_uefi_site_default(version) +} + +fn uefi_creds(password: &str) -> Credentials { + Credentials::UsernamePassword { + username: String::new(), + password: password.to_string(), + } +} + +/// Build a Ready pool host (whose default config carries one DPU) on the shared +/// Redfish sim and return it plus the first DPU's BMC MAC (the key for DPU UEFI +/// rotation bookkeeping). +async fn ready_host_with_dpu(env: &Env) -> (TestManagedHost, MacAddress) { + let domain = env.test_harness.test_domain().await; + let network_controller = env.test_harness.network_controller(); + let underlay_segment = network_controller.create_underlay_segment(&domain).await; + network_controller.create_admin_segment(&domain).await; + let site_explorer = env.test_harness.default_test_site_explorer(); + let mh = env + .test_harness + .managed_host_builder(&site_explorer, underlay_segment) + .with_config(ManagedHostConfig::default()) + .build() + .await + .0; + // Model the converged-Ready invariant the controller establishes before it + // returns a host to Ready (boot interface verified); a plain + // `advance_state(Ready)` would leave a pending boot-config intent that the + // Ready handler converges ahead of the rotation entry guards. + mh.advance_to_converged_ready().await; + + let dpu_mac = mh + .first_dpu() + .machine() + .await + .status + .bmc_info + .mac + .expect("fixture DPU should have a BMC MAC"); + (mh, dpu_mac) +} + +/// Stage a site-wide DPU UEFI rotation to version 1 with the DPU lagging at the +/// v0 baseline: record the device converged at v0, advance the target to 1, and +/// seed the site-wide v1 secret the controller resolves and applies. +async fn stage_lagging_dpu_uefi( + env: &Env, + pool: &PgPool, + dpu_mac: MacAddress, +) -> Result<(), Box> { + { + let mut conn = pool.acquire().await?; + record_device_converged(&mut conn, dpu_mac, DPU_UEFI).await?; + set_next_target_version(&mut conn, DPU_UEFI, 0, serde_json::json!({})) + .await? + .expect("target must advance from version 0"); + } + // The controller resolves the site-wide UEFI credential through the Redfish + // pool's own store, so seed it there rather than in the API credential store. + env.redfish_sim + .seed_credential(&site_key(1), &uefi_creds("dpu-uefi-v1")) + .await; + Ok(()) +} + +/// Advance the controller until the host settles back in Ready, returning the +/// number of iterations taken. Bounded so a wedged FSM fails loudly instead of +/// hanging. +async fn run_until_ready(env: &mut Env, mh: &TestManagedHost) -> usize { + for iteration in 1..=12 { + if matches!(mh.host.machine().await.state.value, ManagedHostState::Ready) { + return iteration - 1; + } + env.run_single_iteration().await; + } + assert!( + matches!(mh.host.machine().await.state.value, ManagedHostState::Ready), + "DPU UEFI rotation FSM did not return to Ready within the iteration budget, got {:?}", + mh.host.machine().await.state.value, + ); + 12 +} + +/// A Ready pool host with a DPU whose tracked DPU UEFI version lags a freshly +/// staged site-wide target rotates that DPU on its own: the entry guard promotes +/// the host to `RotatingDpuUefi` for that DPU, the single-tick state stages the +/// change and restarts the DPU, and the device converges to the target version +/// before returning to Ready. +#[sqlx_test] +async fn ready_dpu_converges_uefi_to_site_target( + pool: PgPool, +) -> Result<(), Box> { + let cm = Arc::new(TestCredentialManager::default()); + let mut env = Env::builder(pool.clone()) + .with_credential_manager(cm.clone()) + // The passive rotation guard is gated behind the site-wide feature flag. + .configure_runtime(|c| c.uefi_rotation_enabled = true) + .build() + .await; + + let (mh, dpu_mac) = ready_host_with_dpu(&env).await; + let dpu_machine_id = mh.first_dpu().id; + stage_lagging_dpu_uefi(&env, &pool, dpu_mac).await?; + + // The device lags the staged target before the controller runs. + { + let mut conn = pool.acquire().await?; + let status = device_rotation_status(&mut conn, DPU_UEFI, dpu_mac) + .await? + .expect("device rotation row should exist"); + assert!( + !status.converged, + "DPU should lag the staged target before rotation" + ); + } + + // Iteration 1: Ready observes the lagging DPU and enters RotatingDpuUefi for + // exactly that DPU. + env.run_single_iteration().await; + assert!( + matches!( + mh.host.machine().await.state.value, + ManagedHostState::RotatingDpuUefi { dpu_machine_id: id } if id == dpu_machine_id + ), + "expected RotatingDpuUefi for the lagging DPU after the entry guard fires, got {:?}", + mh.host.machine().await.state.value, + ); + + // Drive the single-tick state (stage -> DPU restart -> record) until the host + // settles back in Ready. + run_until_ready(&mut env, &mh).await; + + // The DPU is recorded converged at the target version. + { + let mut conn = pool.acquire().await?; + let status = device_rotation_status(&mut conn, DPU_UEFI, dpu_mac) + .await? + .expect("device rotation row should exist"); + assert!(status.converged, "DPU should be converged after rotation"); + assert_eq!( + status.current_version, + Some(1), + "DPU should be recorded at target version 1" + ); + } + + Ok(()) +} + +/// With the site-wide feature flag off (the default), a Ready host with a DPU +/// that lags the staged target must NOT rotate the DPU on its own: the passive +/// gate is the fleet kill-switch, so the host stays Ready and the DPU's tracked +/// version is untouched. +#[sqlx_test] +async fn feature_flag_off_suppresses_passive_dpu_uefi_rotation( + pool: PgPool, +) -> Result<(), Box> { + let cm = Arc::new(TestCredentialManager::default()); + // No configure_runtime: uefi_rotation_enabled defaults to false. + let mut env = Env::builder(pool.clone()) + .with_credential_manager(cm.clone()) + .build() + .await; + + let (mh, dpu_mac) = ready_host_with_dpu(&env).await; + stage_lagging_dpu_uefi(&env, &pool, dpu_mac).await?; + + // A full sweep must leave the host in Ready: the disabled flag keeps the + // passive gate from ever promoting it to RotatingDpuUefi. + env.run_single_iteration().await; + assert!( + matches!(mh.host.machine().await.state.value, ManagedHostState::Ready), + "expected Ready to be preserved while the feature flag is off, got {:?}", + mh.host.machine().await.state.value, + ); + { + let mut conn = pool.acquire().await?; + let status = device_rotation_status(&mut conn, DPU_UEFI, dpu_mac) + .await? + .expect("device rotation row should exist"); + assert!( + !status.converged, + "DPU must remain unrotated while the feature flag is off" + ); + } + + Ok(()) +} + +/// The operator force-converge escape hatch overrides both the site-wide flag +/// (off here) and the DPU's active backoff quarantine: the targeted DPU rotates +/// its UEFI credential on the next sweep and the one-shot request is cleared +/// afterward. +#[sqlx_test] +async fn force_request_converges_quarantined_dpu_uefi_when_disabled( + pool: PgPool, +) -> Result<(), Box> { + let cm = Arc::new(TestCredentialManager::default()); + // Feature flag stays off: only the force request should drive rotation. + let mut env = Env::builder(pool.clone()) + .with_credential_manager(cm.clone()) + .build() + .await; + + let (mh, dpu_mac) = ready_host_with_dpu(&env).await; + let dpu_machine_id = mh.first_dpu().id; + stage_lagging_dpu_uefi(&env, &pool, dpu_mac).await?; + + // Quarantine the DPU (so the passive gate would skip it even if enabled) and + // record the operator's force-converge request on the DPU machine row. + { + let mut conn = pool.acquire().await?; + increment_rotate_attempt( + &mut conn, + dpu_mac, + DPU_UEFI, + "seed backoff", + Utc::now() + Duration::seconds(3600), + ) + .await?; + db::machine::set_uefi_credential_rotation_requested(&mut conn, dpu_machine_id).await?; + } + + // Iteration 1: the force request drives entry into RotatingDpuUefi for the + // targeted DPU despite the disabled flag and the active quarantine. + env.run_single_iteration().await; + assert!( + matches!( + mh.host.machine().await.state.value, + ManagedHostState::RotatingDpuUefi { dpu_machine_id: id } if id == dpu_machine_id + ), + "expected RotatingDpuUefi from the force request, got {:?}", + mh.host.machine().await.state.value, + ); + + // Drive the state until the forced rotation settles in Ready. + run_until_ready(&mut env, &mh).await; + + // The DPU converged despite its quarantine, and the one-shot request was + // cleared so it does not re-enter. + { + let mut conn = pool.acquire().await?; + let status = device_rotation_status(&mut conn, DPU_UEFI, dpu_mac) + .await? + .expect("device rotation row should exist"); + assert!(status.converged, "forced DPU should be converged"); + assert_eq!(status.current_version, Some(1)); + } + assert!( + !mh.first_dpu() + .machine() + .await + .uefi_credential_rotation_requested, + "the one-shot force request must be cleared once rotation settles" + ); + + Ok(()) +} + +/// A device-level DPU UEFI change failure (the BIOS rejects the password change) +/// must not wedge the host in `RotatingDpuUefi`: the state quarantines the DPU +/// with backoff, records a password-redacted error, and returns to Ready so a +/// later sweep can retry once the window elapses. +#[sqlx_test] +async fn dpu_uefi_change_failure_quarantines_and_returns_to_ready( + pool: PgPool, +) -> Result<(), Box> { + let cm = Arc::new(TestCredentialManager::default()); + let mut env = Env::builder(pool.clone()) + .with_credential_manager(cm.clone()) + .configure_runtime(|c| c.uefi_rotation_enabled = true) + .build() + .await; + + let (mh, dpu_mac) = ready_host_with_dpu(&env).await; + stage_lagging_dpu_uefi(&env, &pool, dpu_mac).await?; + + // Model a BIOS that rejects the change. The error carries the new password so + // we can assert the recorded rotation error is redacted end to end. + env.redfish_sim + .set_uefi_password_change_error("boom dpu-uefi-v1 rejected"); + + // Iteration 1: Ready observes the lag and enters RotatingDpuUefi. + env.run_single_iteration().await; + assert!( + matches!( + mh.host.machine().await.state.value, + ManagedHostState::RotatingDpuUefi { .. } + ), + "expected RotatingDpuUefi after the entry guard fires, got {:?}", + mh.host.machine().await.state.value, + ); + + // The failing change must land the host back in Ready rather than looping in + // the state. + run_until_ready(&mut env, &mh).await; + + // The DPU did not converge; it is quarantined with a recorded, redacted error + // and an incremented attempt count. + { + let mut conn = pool.acquire().await?; + let status = device_rotation_status(&mut conn, DPU_UEFI, dpu_mac) + .await? + .expect("device rotation row should exist"); + assert!( + !status.converged, + "a rejected UEFI change must not converge the DPU" + ); + assert!( + status.quarantined, + "a failed attempt must quarantine the DPU with backoff" + ); + assert!( + status.rotate_attempts >= 1, + "a failed attempt must be counted, got {}", + status.rotate_attempts + ); + let recorded = status + .rotate_last_error_redacted + .expect("a failed attempt must record an error"); + assert!( + !recorded.contains("dpu-uefi-v1"), + "the recorded rotation error must be password-redacted, got {recorded:?}" + ); + } + + Ok(()) +} diff --git a/crates/machine-controller/tests/integration/env.rs b/crates/machine-controller/tests/integration/env.rs index 9625e4d3fd..b64f638f56 100644 --- a/crates/machine-controller/tests/integration/env.rs +++ b/crates/machine-controller/tests/integration/env.rs @@ -171,10 +171,15 @@ impl EnvBuilder { db::credential_rotation::CredentialRotationType::Bmc, ), // Zero TTL for the same reason as the BMC gate above. - uefi_rotation_gate: carbide_credential_rotation::RotationGate::with_ttl_and_family( + host_uefi_rotation_gate: carbide_credential_rotation::RotationGate::with_ttl_and_family( std::time::Duration::ZERO, db::credential_rotation::CredentialRotationType::HostUefi, ), + // Zero TTL for the same reason as the BMC gate above. + dpu_uefi_rotation_gate: carbide_credential_rotation::RotationGate::with_ttl_and_family( + std::time::Duration::ZERO, + db::credential_rotation::CredentialRotationType::DpuUefi, + ), per_object_metrics_registry, per_object_info: None, }; diff --git a/crates/machine-controller/tests/integration/main.rs b/crates/machine-controller/tests/integration/main.rs index 5f986a57aa..6c8f1616e3 100644 --- a/crates/machine-controller/tests/integration/main.rs +++ b/crates/machine-controller/tests/integration/main.rs @@ -17,6 +17,7 @@ // Keep the suites in one executable: sqlx-testing's migrated template is process-local. mod bmc_rotation; +mod dpu_uefi_rotation; mod env; mod firmware_upgrade_completion; mod host_uefi_rotation; diff --git a/crates/power-shelf-controller/src/context.rs b/crates/power-shelf-controller/src/context.rs index 4909994f7c..078ad39755 100644 --- a/crates/power-shelf-controller/src/context.rs +++ b/crates/power-shelf-controller/src/context.rs @@ -42,7 +42,7 @@ pub struct PowerShelfStateHandlerServices { /// enabled. pub rack_firmware_reprovisioning_enabled: bool, /// Libredfish pool used to converge the power shelf BMC (PMC) credential - /// (REQ-2). The same shared instance the machine- and switch-controllers use. + /// The same shared instance the machine- and switch-controllers use. pub redfish_client_pool: Arc, /// Short-TTL cache of the site-wide BMC rotation aggregate, shared across /// this replica's per-object ticks so the steady state costs one aggregate diff --git a/crates/power-shelf-controller/src/rotating_bmc.rs b/crates/power-shelf-controller/src/rotating_bmc.rs index 975c70e942..ce46f8e705 100644 --- a/crates/power-shelf-controller/src/rotating_bmc.rs +++ b/crates/power-shelf-controller/src/rotating_bmc.rs @@ -15,7 +15,7 @@ * limitations under the License. */ -//! Power-shelf-controller BMC (PMC) credential rotation (REQ-2). +//! Power-shelf-controller BMC (PMC) credential rotation. //! //! The shared [`carbide_credential_rotation`] engine owns the password dance, //! backoff, and crash-safety; this module is the thin power-shelf-controller diff --git a/crates/redfish/src/libredfish/mod.rs b/crates/redfish/src/libredfish/mod.rs index e6892ddb2b..4e3d3f618b 100644 --- a/crates/redfish/src/libredfish/mod.rs +++ b/crates/redfish/src/libredfish/mod.rs @@ -287,22 +287,25 @@ pub trait RedfishClientPool: Send + Sync + 'static { .map_err(RedfishClientCreationError::RedfishError) } - /// Rotate a *host* UEFI (BIOS setup) password to the site-wide target, - /// authenticating with the current-version credential. + /// Rotate a UEFI (BIOS setup) password to the site-wide target, + /// authenticating with the current-version credential. Family-agnostic: the + /// same candidate walk serves a host (via a host power-cycle) and a DPU (via + /// a DPU restart) -- the caller owns the reboot and the bookkeeping. /// /// `current_password_candidates` is an ordered, bounded, non-empty list of /// plausible current passwords (the caller resolves them: the device's - /// tracked current site version, then the rotating-to version, then empty - /// for a never-set host). The first candidate that authenticates the change - /// wins; the returned `Option` is the vendor BIOS job id to poll - /// (when the vendor schedules one) or `None`. + /// tracked current site version, then the rotating-to version, then the + /// terminal fallback -- empty for a never-set host, the factory default for + /// a never-set DPU). The first candidate that authenticates the change wins; + /// the returned `Option` is the vendor BIOS job id to poll (when the + /// vendor schedules one) or `None` (DPUs never schedule one). /// /// Unlike [`Self::uefi_setup`], this never assumes the empty/factory case - /// first, so a mid-rotation host at v1 rotating to v2 authenticates with the - /// v1 secret rather than failing. This crate still knows nothing about + /// first, so a mid-rotation device at v1 rotating to v2 authenticates with + /// the v1 secret rather than failing. This crate still knows nothing about /// credential versions -- it just applies the ordered candidates it is /// handed. All errors are password-redacted before they leave this method. - async fn rotate_host_uefi_password( + async fn rotate_uefi_password( &self, client: &dyn Redfish, current_password_candidates: &[String], @@ -320,17 +323,17 @@ pub trait RedfishClientPool: Send + Sync + 'static { redact_passwords(e, &[new_password.as_str(), candidate.as_str()]); tracing::warn!( error = %redacted, - "host UEFI password change failed for a current-password candidate; trying the next" + "UEFI password change failed for a current-password candidate; trying the next" ); last_err = Some(redacted); } } } - // The caller contract guarantees at least one candidate (empty string - // for a never-set host), so `last_err` is populated whenever the loop - // fell through without an Ok. + // The caller contract guarantees at least one candidate (empty for a + // never-set host, the factory default for a never-set DPU), so `last_err` + // is populated whenever the loop fell through without an Ok. Err(RedfishClientCreationError::RedfishError(last_err.expect( - "rotate_host_uefi_password requires at least one current-password candidate", + "rotate_uefi_password requires at least one current-password candidate", ))) } diff --git a/crates/rpc/proto/forge.proto b/crates/rpc/proto/forge.proto index 8327b6c3e3..64d814ca16 100644 --- a/crates/rpc/proto/forge.proto +++ b/crates/rpc/proto/forge.proto @@ -449,6 +449,11 @@ service Forge { rpc SetHostUefiPassword(SetHostUefiPasswordRequest) returns (SetHostUefiPasswordResponse); rpc ClearHostUefiPassword(ClearHostUefiPasswordRequest) returns (ClearHostUefiPasswordResponse); + // Set a DPU's UEFI password directly on the device (the DPU equivalent of + // SetHostUefiPassword): stage the site-wide DPU UEFI credential through the + // DPU's Redfish BIOS settings and restart the DPU to commit it. + rpc SetDpuUefiPassword(SetDpuUefiPasswordRequest) returns (SetDpuUefiPasswordResponse); + // Expected Machine Management // Add expected machine rpc AddExpectedMachine(ExpectedMachine) returns (google.protobuf.Empty); @@ -6198,6 +6203,19 @@ message ClearHostUefiPasswordResponse { optional string job_id = 1; } +message SetDpuUefiPasswordRequest { + // The DPU machine to set the UEFI password on. + common.MachineId dpu_id = 1; + // UUID, IP address, hostname or MAC address resolving to the DPU machine + // (preferred over dpu_id). + optional string machine_query = 2; +} + +message SetDpuUefiPasswordResponse { + // A DPU stages the change through Redfish BIOS settings and schedules no job, + // so there is nothing to poll and no job id is returned. +} + enum OsImageStatus { // default status when entry created ImageUninitialized = 0; diff --git a/crates/switch-controller/src/context.rs b/crates/switch-controller/src/context.rs index 184c3efdcf..4cdd095efb 100644 --- a/crates/switch-controller/src/context.rs +++ b/crates/switch-controller/src/context.rs @@ -38,7 +38,7 @@ pub struct SwitchStateHandlerServices { pub switch_mtls_services: Vec, /// Shared registry backing the generic per-object health metrics. pub per_object_metrics_registry: Arc, - /// Libredfish pool used to converge the switch BMC credential (REQ-2). The + /// Libredfish pool used to converge the switch BMC credential. The /// same shared instance the machine-controller uses. pub redfish_client_pool: Arc, /// Short-TTL cache of the site-wide BMC rotation aggregate, shared across diff --git a/crates/switch-controller/src/rotating_bmc.rs b/crates/switch-controller/src/rotating_bmc.rs index eadd04d293..9abb0ded19 100644 --- a/crates/switch-controller/src/rotating_bmc.rs +++ b/crates/switch-controller/src/rotating_bmc.rs @@ -15,7 +15,7 @@ * limitations under the License. */ -//! Switch-controller BMC credential rotation (REQ-2). +//! Switch-controller BMC credential rotation. //! //! The shared [`carbide_credential_rotation`] engine owns the password dance, //! backoff, and crash-safety; this module is the thin switch-controller adapter, diff --git a/rest-api/proto/core/gen/v1/nico_nico.pb.go b/rest-api/proto/core/gen/v1/nico_nico.pb.go index 4350d847eb..94f4d0d863 100644 --- a/rest-api/proto/core/gen/v1/nico_nico.pb.go +++ b/rest-api/proto/core/gen/v1/nico_nico.pb.go @@ -5283,7 +5283,7 @@ func (x MachineSetAutoUpdateRequest_SetAutoupdateAction) Number() protoreflect.E // Deprecated: Use MachineSetAutoUpdateRequest_SetAutoupdateAction.Descriptor instead. func (MachineSetAutoUpdateRequest_SetAutoupdateAction) EnumDescriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{491, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{493, 0} } type MachineValidationOnDemandRequest_Action int32 @@ -5329,7 +5329,7 @@ func (x MachineValidationOnDemandRequest_Action) Number() protoreflect.EnumNumbe // Deprecated: Use MachineValidationOnDemandRequest_Action.Descriptor instead. func (MachineValidationOnDemandRequest_Action) EnumDescriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{500, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{502, 0} } type AdminPowerControlRequest_SystemPowerControl int32 @@ -5393,7 +5393,7 @@ func (x AdminPowerControlRequest_SystemPowerControl) Number() protoreflect.EnumN // Deprecated: Use AdminPowerControlRequest_SystemPowerControl.Descriptor instead. func (AdminPowerControlRequest_SystemPowerControl) EnumDescriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{510, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{512, 0} } type GetRedfishJobStateResponse_RedfishJobState int32 @@ -5448,7 +5448,7 @@ func (x GetRedfishJobStateResponse_RedfishJobState) Number() protoreflect.EnumNu // Deprecated: Use GetRedfishJobStateResponse_RedfishJobState.Descriptor instead. func (GetRedfishJobStateResponse_RedfishJobState) EnumDescriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{513, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{515, 0} } // Whether the desired generation is waiting for, undergoing, or has @@ -5512,7 +5512,7 @@ func (x GetMachineBootInterfacesResponse_Reconciliation_State) Number() protoref // Deprecated: Use GetMachineBootInterfacesResponse_Reconciliation_State.Descriptor instead. func (GetMachineBootInterfacesResponse_Reconciliation_State) EnumDescriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{864, 0, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{866, 0, 0} } // Indicates the lifecycle state of a resource that is controlled by a state controller @@ -35486,6 +35486,97 @@ func (x *ClearHostUefiPasswordResponse) GetJobId() string { return "" } +type SetDpuUefiPasswordRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The DPU machine to set the UEFI password on. + DpuId *MachineId `protobuf:"bytes,1,opt,name=dpu_id,json=dpuId,proto3" json:"dpu_id,omitempty"` + // UUID, IP address, hostname or MAC address resolving to the DPU machine + // (preferred over dpu_id). + MachineQuery *string `protobuf:"bytes,2,opt,name=machine_query,json=machineQuery,proto3,oneof" json:"machine_query,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetDpuUefiPasswordRequest) Reset() { + *x = SetDpuUefiPasswordRequest{} + mi := &file_nico_nico_proto_msgTypes[459] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetDpuUefiPasswordRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetDpuUefiPasswordRequest) ProtoMessage() {} + +func (x *SetDpuUefiPasswordRequest) ProtoReflect() protoreflect.Message { + mi := &file_nico_nico_proto_msgTypes[459] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetDpuUefiPasswordRequest.ProtoReflect.Descriptor instead. +func (*SetDpuUefiPasswordRequest) Descriptor() ([]byte, []int) { + return file_nico_nico_proto_rawDescGZIP(), []int{459} +} + +func (x *SetDpuUefiPasswordRequest) GetDpuId() *MachineId { + if x != nil { + return x.DpuId + } + return nil +} + +func (x *SetDpuUefiPasswordRequest) GetMachineQuery() string { + if x != nil && x.MachineQuery != nil { + return *x.MachineQuery + } + return "" +} + +type SetDpuUefiPasswordResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetDpuUefiPasswordResponse) Reset() { + *x = SetDpuUefiPasswordResponse{} + mi := &file_nico_nico_proto_msgTypes[460] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetDpuUefiPasswordResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetDpuUefiPasswordResponse) ProtoMessage() {} + +func (x *SetDpuUefiPasswordResponse) ProtoReflect() protoreflect.Message { + mi := &file_nico_nico_proto_msgTypes[460] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetDpuUefiPasswordResponse.ProtoReflect.Descriptor instead. +func (*SetDpuUefiPasswordResponse) Descriptor() ([]byte, []int) { + return file_nico_nico_proto_rawDescGZIP(), []int{460} +} + type OsImageAttributes struct { state protoimpl.MessageState `protogen:"open.v1"` // needs to be generated by the caller (cloud) during CreateOsImage call @@ -35512,7 +35603,7 @@ type OsImageAttributes struct { func (x *OsImageAttributes) Reset() { *x = OsImageAttributes{} - mi := &file_nico_nico_proto_msgTypes[459] + mi := &file_nico_nico_proto_msgTypes[461] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35524,7 +35615,7 @@ func (x *OsImageAttributes) String() string { func (*OsImageAttributes) ProtoMessage() {} func (x *OsImageAttributes) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[459] + mi := &file_nico_nico_proto_msgTypes[461] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35537,7 +35628,7 @@ func (x *OsImageAttributes) ProtoReflect() protoreflect.Message { // Deprecated: Use OsImageAttributes.ProtoReflect.Descriptor instead. func (*OsImageAttributes) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{459} + return file_nico_nico_proto_rawDescGZIP(), []int{461} } func (x *OsImageAttributes) GetId() *UUID { @@ -35658,7 +35749,7 @@ type OsImage struct { func (x *OsImage) Reset() { *x = OsImage{} - mi := &file_nico_nico_proto_msgTypes[460] + mi := &file_nico_nico_proto_msgTypes[462] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35670,7 +35761,7 @@ func (x *OsImage) String() string { func (*OsImage) ProtoMessage() {} func (x *OsImage) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[460] + mi := &file_nico_nico_proto_msgTypes[462] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35683,7 +35774,7 @@ func (x *OsImage) ProtoReflect() protoreflect.Message { // Deprecated: Use OsImage.ProtoReflect.Descriptor instead. func (*OsImage) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{460} + return file_nico_nico_proto_rawDescGZIP(), []int{462} } func (x *OsImage) GetAttributes() *OsImageAttributes { @@ -35730,7 +35821,7 @@ type ListOsImageRequest struct { func (x *ListOsImageRequest) Reset() { *x = ListOsImageRequest{} - mi := &file_nico_nico_proto_msgTypes[461] + mi := &file_nico_nico_proto_msgTypes[463] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35742,7 +35833,7 @@ func (x *ListOsImageRequest) String() string { func (*ListOsImageRequest) ProtoMessage() {} func (x *ListOsImageRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[461] + mi := &file_nico_nico_proto_msgTypes[463] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35755,7 +35846,7 @@ func (x *ListOsImageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOsImageRequest.ProtoReflect.Descriptor instead. func (*ListOsImageRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{461} + return file_nico_nico_proto_rawDescGZIP(), []int{463} } func (x *ListOsImageRequest) GetTenantOrganizationId() string { @@ -35774,7 +35865,7 @@ type ListOsImageResponse struct { func (x *ListOsImageResponse) Reset() { *x = ListOsImageResponse{} - mi := &file_nico_nico_proto_msgTypes[462] + mi := &file_nico_nico_proto_msgTypes[464] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35786,7 +35877,7 @@ func (x *ListOsImageResponse) String() string { func (*ListOsImageResponse) ProtoMessage() {} func (x *ListOsImageResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[462] + mi := &file_nico_nico_proto_msgTypes[464] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35799,7 +35890,7 @@ func (x *ListOsImageResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOsImageResponse.ProtoReflect.Descriptor instead. func (*ListOsImageResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{462} + return file_nico_nico_proto_rawDescGZIP(), []int{464} } func (x *ListOsImageResponse) GetImages() []*OsImage { @@ -35819,7 +35910,7 @@ type DeleteOsImageRequest struct { func (x *DeleteOsImageRequest) Reset() { *x = DeleteOsImageRequest{} - mi := &file_nico_nico_proto_msgTypes[463] + mi := &file_nico_nico_proto_msgTypes[465] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35831,7 +35922,7 @@ func (x *DeleteOsImageRequest) String() string { func (*DeleteOsImageRequest) ProtoMessage() {} func (x *DeleteOsImageRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[463] + mi := &file_nico_nico_proto_msgTypes[465] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35844,7 +35935,7 @@ func (x *DeleteOsImageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteOsImageRequest.ProtoReflect.Descriptor instead. func (*DeleteOsImageRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{463} + return file_nico_nico_proto_rawDescGZIP(), []int{465} } func (x *DeleteOsImageRequest) GetId() *UUID { @@ -35869,7 +35960,7 @@ type DeleteOsImageResponse struct { func (x *DeleteOsImageResponse) Reset() { *x = DeleteOsImageResponse{} - mi := &file_nico_nico_proto_msgTypes[464] + mi := &file_nico_nico_proto_msgTypes[466] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35881,7 +35972,7 @@ func (x *DeleteOsImageResponse) String() string { func (*DeleteOsImageResponse) ProtoMessage() {} func (x *DeleteOsImageResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[464] + mi := &file_nico_nico_proto_msgTypes[466] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35894,7 +35985,7 @@ func (x *DeleteOsImageResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteOsImageResponse.ProtoReflect.Descriptor instead. func (*DeleteOsImageResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{464} + return file_nico_nico_proto_rawDescGZIP(), []int{466} } // Request/Response messages for iPXE Script Template management @@ -35907,7 +35998,7 @@ type GetIpxeTemplateRequest struct { func (x *GetIpxeTemplateRequest) Reset() { *x = GetIpxeTemplateRequest{} - mi := &file_nico_nico_proto_msgTypes[465] + mi := &file_nico_nico_proto_msgTypes[467] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35919,7 +36010,7 @@ func (x *GetIpxeTemplateRequest) String() string { func (*GetIpxeTemplateRequest) ProtoMessage() {} func (x *GetIpxeTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[465] + mi := &file_nico_nico_proto_msgTypes[467] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35932,7 +36023,7 @@ func (x *GetIpxeTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetIpxeTemplateRequest.ProtoReflect.Descriptor instead. func (*GetIpxeTemplateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{465} + return file_nico_nico_proto_rawDescGZIP(), []int{467} } func (x *GetIpxeTemplateRequest) GetId() *IpxeTemplateId { @@ -35950,7 +36041,7 @@ type ListIpxeTemplatesRequest struct { func (x *ListIpxeTemplatesRequest) Reset() { *x = ListIpxeTemplatesRequest{} - mi := &file_nico_nico_proto_msgTypes[466] + mi := &file_nico_nico_proto_msgTypes[468] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35962,7 +36053,7 @@ func (x *ListIpxeTemplatesRequest) String() string { func (*ListIpxeTemplatesRequest) ProtoMessage() {} func (x *ListIpxeTemplatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[466] + mi := &file_nico_nico_proto_msgTypes[468] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -35975,7 +36066,7 @@ func (x *ListIpxeTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListIpxeTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListIpxeTemplatesRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{466} + return file_nico_nico_proto_rawDescGZIP(), []int{468} } type IpxeTemplateList struct { @@ -35987,7 +36078,7 @@ type IpxeTemplateList struct { func (x *IpxeTemplateList) Reset() { *x = IpxeTemplateList{} - mi := &file_nico_nico_proto_msgTypes[467] + mi := &file_nico_nico_proto_msgTypes[469] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -35999,7 +36090,7 @@ func (x *IpxeTemplateList) String() string { func (*IpxeTemplateList) ProtoMessage() {} func (x *IpxeTemplateList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[467] + mi := &file_nico_nico_proto_msgTypes[469] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36012,7 +36103,7 @@ func (x *IpxeTemplateList) ProtoReflect() protoreflect.Message { // Deprecated: Use IpxeTemplateList.ProtoReflect.Descriptor instead. func (*IpxeTemplateList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{467} + return file_nico_nico_proto_rawDescGZIP(), []int{469} } func (x *IpxeTemplateList) GetTemplates() []*IpxeTemplate { @@ -36071,7 +36162,7 @@ type ExpectedHostNic struct { func (x *ExpectedHostNic) Reset() { *x = ExpectedHostNic{} - mi := &file_nico_nico_proto_msgTypes[468] + mi := &file_nico_nico_proto_msgTypes[470] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36083,7 +36174,7 @@ func (x *ExpectedHostNic) String() string { func (*ExpectedHostNic) ProtoMessage() {} func (x *ExpectedHostNic) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[468] + mi := &file_nico_nico_proto_msgTypes[470] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36096,7 +36187,7 @@ func (x *ExpectedHostNic) ProtoReflect() protoreflect.Message { // Deprecated: Use ExpectedHostNic.ProtoReflect.Descriptor instead. func (*ExpectedHostNic) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{468} + return file_nico_nico_proto_rawDescGZIP(), []int{470} } func (x *ExpectedHostNic) GetMacAddress() string { @@ -36176,7 +36267,7 @@ type HostLifecycleProfile struct { func (x *HostLifecycleProfile) Reset() { *x = HostLifecycleProfile{} - mi := &file_nico_nico_proto_msgTypes[469] + mi := &file_nico_nico_proto_msgTypes[471] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36188,7 +36279,7 @@ func (x *HostLifecycleProfile) String() string { func (*HostLifecycleProfile) ProtoMessage() {} func (x *HostLifecycleProfile) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[469] + mi := &file_nico_nico_proto_msgTypes[471] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36201,7 +36292,7 @@ func (x *HostLifecycleProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use HostLifecycleProfile.ProtoReflect.Descriptor instead. func (*HostLifecycleProfile) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{469} + return file_nico_nico_proto_rawDescGZIP(), []int{471} } func (x *HostLifecycleProfile) GetDisableLockdown() bool { @@ -36278,7 +36369,7 @@ type ExpectedMachine struct { func (x *ExpectedMachine) Reset() { *x = ExpectedMachine{} - mi := &file_nico_nico_proto_msgTypes[470] + mi := &file_nico_nico_proto_msgTypes[472] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36290,7 +36381,7 @@ func (x *ExpectedMachine) String() string { func (*ExpectedMachine) ProtoMessage() {} func (x *ExpectedMachine) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[470] + mi := &file_nico_nico_proto_msgTypes[472] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36303,7 +36394,7 @@ func (x *ExpectedMachine) ProtoReflect() protoreflect.Message { // Deprecated: Use ExpectedMachine.ProtoReflect.Descriptor instead. func (*ExpectedMachine) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{470} + return file_nico_nico_proto_rawDescGZIP(), []int{472} } func (x *ExpectedMachine) GetBmcMacAddress() string { @@ -36508,7 +36599,7 @@ type ExpectedMachineRequest struct { func (x *ExpectedMachineRequest) Reset() { *x = ExpectedMachineRequest{} - mi := &file_nico_nico_proto_msgTypes[471] + mi := &file_nico_nico_proto_msgTypes[473] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36520,7 +36611,7 @@ func (x *ExpectedMachineRequest) String() string { func (*ExpectedMachineRequest) ProtoMessage() {} func (x *ExpectedMachineRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[471] + mi := &file_nico_nico_proto_msgTypes[473] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36533,7 +36624,7 @@ func (x *ExpectedMachineRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExpectedMachineRequest.ProtoReflect.Descriptor instead. func (*ExpectedMachineRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{471} + return file_nico_nico_proto_rawDescGZIP(), []int{473} } func (x *ExpectedMachineRequest) GetBmcMacAddress() string { @@ -36559,7 +36650,7 @@ type ExpectedMachineList struct { func (x *ExpectedMachineList) Reset() { *x = ExpectedMachineList{} - mi := &file_nico_nico_proto_msgTypes[472] + mi := &file_nico_nico_proto_msgTypes[474] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36571,7 +36662,7 @@ func (x *ExpectedMachineList) String() string { func (*ExpectedMachineList) ProtoMessage() {} func (x *ExpectedMachineList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[472] + mi := &file_nico_nico_proto_msgTypes[474] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36584,7 +36675,7 @@ func (x *ExpectedMachineList) ProtoReflect() protoreflect.Message { // Deprecated: Use ExpectedMachineList.ProtoReflect.Descriptor instead. func (*ExpectedMachineList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{472} + return file_nico_nico_proto_rawDescGZIP(), []int{474} } func (x *ExpectedMachineList) GetExpectedMachines() []*ExpectedMachine { @@ -36603,7 +36694,7 @@ type LinkedExpectedMachineList struct { func (x *LinkedExpectedMachineList) Reset() { *x = LinkedExpectedMachineList{} - mi := &file_nico_nico_proto_msgTypes[473] + mi := &file_nico_nico_proto_msgTypes[475] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36615,7 +36706,7 @@ func (x *LinkedExpectedMachineList) String() string { func (*LinkedExpectedMachineList) ProtoMessage() {} func (x *LinkedExpectedMachineList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[473] + mi := &file_nico_nico_proto_msgTypes[475] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36628,7 +36719,7 @@ func (x *LinkedExpectedMachineList) ProtoReflect() protoreflect.Message { // Deprecated: Use LinkedExpectedMachineList.ProtoReflect.Descriptor instead. func (*LinkedExpectedMachineList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{473} + return file_nico_nico_proto_rawDescGZIP(), []int{475} } func (x *LinkedExpectedMachineList) GetExpectedMachines() []*LinkedExpectedMachine { @@ -36652,7 +36743,7 @@ type LinkedExpectedMachine struct { func (x *LinkedExpectedMachine) Reset() { *x = LinkedExpectedMachine{} - mi := &file_nico_nico_proto_msgTypes[474] + mi := &file_nico_nico_proto_msgTypes[476] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36664,7 +36755,7 @@ func (x *LinkedExpectedMachine) String() string { func (*LinkedExpectedMachine) ProtoMessage() {} func (x *LinkedExpectedMachine) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[474] + mi := &file_nico_nico_proto_msgTypes[476] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36677,7 +36768,7 @@ func (x *LinkedExpectedMachine) ProtoReflect() protoreflect.Message { // Deprecated: Use LinkedExpectedMachine.ProtoReflect.Descriptor instead. func (*LinkedExpectedMachine) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{474} + return file_nico_nico_proto_rawDescGZIP(), []int{476} } func (x *LinkedExpectedMachine) GetChassisSerialNumber() string { @@ -36731,7 +36822,7 @@ type UnexpectedMachineList struct { func (x *UnexpectedMachineList) Reset() { *x = UnexpectedMachineList{} - mi := &file_nico_nico_proto_msgTypes[475] + mi := &file_nico_nico_proto_msgTypes[477] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36743,7 +36834,7 @@ func (x *UnexpectedMachineList) String() string { func (*UnexpectedMachineList) ProtoMessage() {} func (x *UnexpectedMachineList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[475] + mi := &file_nico_nico_proto_msgTypes[477] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36756,7 +36847,7 @@ func (x *UnexpectedMachineList) ProtoReflect() protoreflect.Message { // Deprecated: Use UnexpectedMachineList.ProtoReflect.Descriptor instead. func (*UnexpectedMachineList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{475} + return file_nico_nico_proto_rawDescGZIP(), []int{477} } func (x *UnexpectedMachineList) GetUnexpectedMachines() []*UnexpectedMachine { @@ -36777,7 +36868,7 @@ type UnexpectedMachine struct { func (x *UnexpectedMachine) Reset() { *x = UnexpectedMachine{} - mi := &file_nico_nico_proto_msgTypes[476] + mi := &file_nico_nico_proto_msgTypes[478] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36789,7 +36880,7 @@ func (x *UnexpectedMachine) String() string { func (*UnexpectedMachine) ProtoMessage() {} func (x *UnexpectedMachine) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[476] + mi := &file_nico_nico_proto_msgTypes[478] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36802,7 +36893,7 @@ func (x *UnexpectedMachine) ProtoReflect() protoreflect.Message { // Deprecated: Use UnexpectedMachine.ProtoReflect.Descriptor instead. func (*UnexpectedMachine) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{476} + return file_nico_nico_proto_rawDescGZIP(), []int{478} } func (x *UnexpectedMachine) GetAddress() string { @@ -36838,7 +36929,7 @@ type BatchExpectedMachineOperationRequest struct { func (x *BatchExpectedMachineOperationRequest) Reset() { *x = BatchExpectedMachineOperationRequest{} - mi := &file_nico_nico_proto_msgTypes[477] + mi := &file_nico_nico_proto_msgTypes[479] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36850,7 +36941,7 @@ func (x *BatchExpectedMachineOperationRequest) String() string { func (*BatchExpectedMachineOperationRequest) ProtoMessage() {} func (x *BatchExpectedMachineOperationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[477] + mi := &file_nico_nico_proto_msgTypes[479] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36863,7 +36954,7 @@ func (x *BatchExpectedMachineOperationRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use BatchExpectedMachineOperationRequest.ProtoReflect.Descriptor instead. func (*BatchExpectedMachineOperationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{477} + return file_nico_nico_proto_rawDescGZIP(), []int{479} } func (x *BatchExpectedMachineOperationRequest) GetExpectedMachines() *ExpectedMachineList { @@ -36896,7 +36987,7 @@ type ExpectedMachineOperationResult struct { func (x *ExpectedMachineOperationResult) Reset() { *x = ExpectedMachineOperationResult{} - mi := &file_nico_nico_proto_msgTypes[478] + mi := &file_nico_nico_proto_msgTypes[480] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36908,7 +36999,7 @@ func (x *ExpectedMachineOperationResult) String() string { func (*ExpectedMachineOperationResult) ProtoMessage() {} func (x *ExpectedMachineOperationResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[478] + mi := &file_nico_nico_proto_msgTypes[480] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36921,7 +37012,7 @@ func (x *ExpectedMachineOperationResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ExpectedMachineOperationResult.ProtoReflect.Descriptor instead. func (*ExpectedMachineOperationResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{478} + return file_nico_nico_proto_rawDescGZIP(), []int{480} } func (x *ExpectedMachineOperationResult) GetId() *UUID { @@ -36962,7 +37053,7 @@ type BatchExpectedMachineOperationResponse struct { func (x *BatchExpectedMachineOperationResponse) Reset() { *x = BatchExpectedMachineOperationResponse{} - mi := &file_nico_nico_proto_msgTypes[479] + mi := &file_nico_nico_proto_msgTypes[481] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -36974,7 +37065,7 @@ func (x *BatchExpectedMachineOperationResponse) String() string { func (*BatchExpectedMachineOperationResponse) ProtoMessage() {} func (x *BatchExpectedMachineOperationResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[479] + mi := &file_nico_nico_proto_msgTypes[481] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -36987,7 +37078,7 @@ func (x *BatchExpectedMachineOperationResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use BatchExpectedMachineOperationResponse.ProtoReflect.Descriptor instead. func (*BatchExpectedMachineOperationResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{479} + return file_nico_nico_proto_rawDescGZIP(), []int{481} } func (x *BatchExpectedMachineOperationResponse) GetResults() []*ExpectedMachineOperationResult { @@ -37005,7 +37096,7 @@ type MachineRebootCompletedResponse struct { func (x *MachineRebootCompletedResponse) Reset() { *x = MachineRebootCompletedResponse{} - mi := &file_nico_nico_proto_msgTypes[480] + mi := &file_nico_nico_proto_msgTypes[482] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37017,7 +37108,7 @@ func (x *MachineRebootCompletedResponse) String() string { func (*MachineRebootCompletedResponse) ProtoMessage() {} func (x *MachineRebootCompletedResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[480] + mi := &file_nico_nico_proto_msgTypes[482] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37030,7 +37121,7 @@ func (x *MachineRebootCompletedResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineRebootCompletedResponse.ProtoReflect.Descriptor instead. func (*MachineRebootCompletedResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{480} + return file_nico_nico_proto_rawDescGZIP(), []int{482} } type MachineRebootCompletedRequest struct { @@ -37042,7 +37133,7 @@ type MachineRebootCompletedRequest struct { func (x *MachineRebootCompletedRequest) Reset() { *x = MachineRebootCompletedRequest{} - mi := &file_nico_nico_proto_msgTypes[481] + mi := &file_nico_nico_proto_msgTypes[483] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37054,7 +37145,7 @@ func (x *MachineRebootCompletedRequest) String() string { func (*MachineRebootCompletedRequest) ProtoMessage() {} func (x *MachineRebootCompletedRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[481] + mi := &file_nico_nico_proto_msgTypes[483] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37067,7 +37158,7 @@ func (x *MachineRebootCompletedRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineRebootCompletedRequest.ProtoReflect.Descriptor instead. func (*MachineRebootCompletedRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{481} + return file_nico_nico_proto_rawDescGZIP(), []int{483} } func (x *MachineRebootCompletedRequest) GetMachineId() *MachineId { @@ -37092,7 +37183,7 @@ type ScoutFirmwareUpgradeStatusRequest struct { func (x *ScoutFirmwareUpgradeStatusRequest) Reset() { *x = ScoutFirmwareUpgradeStatusRequest{} - mi := &file_nico_nico_proto_msgTypes[482] + mi := &file_nico_nico_proto_msgTypes[484] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37104,7 +37195,7 @@ func (x *ScoutFirmwareUpgradeStatusRequest) String() string { func (*ScoutFirmwareUpgradeStatusRequest) ProtoMessage() {} func (x *ScoutFirmwareUpgradeStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[482] + mi := &file_nico_nico_proto_msgTypes[484] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37117,7 +37208,7 @@ func (x *ScoutFirmwareUpgradeStatusRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ScoutFirmwareUpgradeStatusRequest.ProtoReflect.Descriptor instead. func (*ScoutFirmwareUpgradeStatusRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{482} + return file_nico_nico_proto_rawDescGZIP(), []int{484} } func (x *ScoutFirmwareUpgradeStatusRequest) GetMachineId() *MachineId { @@ -37180,7 +37271,7 @@ type MachineValidationCompletedRequest struct { func (x *MachineValidationCompletedRequest) Reset() { *x = MachineValidationCompletedRequest{} - mi := &file_nico_nico_proto_msgTypes[483] + mi := &file_nico_nico_proto_msgTypes[485] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37192,7 +37283,7 @@ func (x *MachineValidationCompletedRequest) String() string { func (*MachineValidationCompletedRequest) ProtoMessage() {} func (x *MachineValidationCompletedRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[483] + mi := &file_nico_nico_proto_msgTypes[485] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37205,7 +37296,7 @@ func (x *MachineValidationCompletedRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationCompletedRequest.ProtoReflect.Descriptor instead. func (*MachineValidationCompletedRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{483} + return file_nico_nico_proto_rawDescGZIP(), []int{485} } func (x *MachineValidationCompletedRequest) GetMachineId() *MachineId { @@ -37237,7 +37328,7 @@ type MachineValidationCompletedResponse struct { func (x *MachineValidationCompletedResponse) Reset() { *x = MachineValidationCompletedResponse{} - mi := &file_nico_nico_proto_msgTypes[484] + mi := &file_nico_nico_proto_msgTypes[486] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37249,7 +37340,7 @@ func (x *MachineValidationCompletedResponse) String() string { func (*MachineValidationCompletedResponse) ProtoMessage() {} func (x *MachineValidationCompletedResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[484] + mi := &file_nico_nico_proto_msgTypes[486] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37262,7 +37353,7 @@ func (x *MachineValidationCompletedResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationCompletedResponse.ProtoReflect.Descriptor instead. func (*MachineValidationCompletedResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{484} + return file_nico_nico_proto_rawDescGZIP(), []int{486} } type MachineValidationResult struct { @@ -37285,7 +37376,7 @@ type MachineValidationResult struct { func (x *MachineValidationResult) Reset() { *x = MachineValidationResult{} - mi := &file_nico_nico_proto_msgTypes[485] + mi := &file_nico_nico_proto_msgTypes[487] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37297,7 +37388,7 @@ func (x *MachineValidationResult) String() string { func (*MachineValidationResult) ProtoMessage() {} func (x *MachineValidationResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[485] + mi := &file_nico_nico_proto_msgTypes[487] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37310,7 +37401,7 @@ func (x *MachineValidationResult) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationResult.ProtoReflect.Descriptor instead. func (*MachineValidationResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{485} + return file_nico_nico_proto_rawDescGZIP(), []int{487} } func (x *MachineValidationResult) GetName() string { @@ -37406,7 +37497,7 @@ type MachineValidationResultPostRequest struct { func (x *MachineValidationResultPostRequest) Reset() { *x = MachineValidationResultPostRequest{} - mi := &file_nico_nico_proto_msgTypes[486] + mi := &file_nico_nico_proto_msgTypes[488] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37418,7 +37509,7 @@ func (x *MachineValidationResultPostRequest) String() string { func (*MachineValidationResultPostRequest) ProtoMessage() {} func (x *MachineValidationResultPostRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[486] + mi := &file_nico_nico_proto_msgTypes[488] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37431,7 +37522,7 @@ func (x *MachineValidationResultPostRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationResultPostRequest.ProtoReflect.Descriptor instead. func (*MachineValidationResultPostRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{486} + return file_nico_nico_proto_rawDescGZIP(), []int{488} } func (x *MachineValidationResultPostRequest) GetResult() *MachineValidationResult { @@ -37450,7 +37541,7 @@ type MachineValidationResultList struct { func (x *MachineValidationResultList) Reset() { *x = MachineValidationResultList{} - mi := &file_nico_nico_proto_msgTypes[487] + mi := &file_nico_nico_proto_msgTypes[489] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37462,7 +37553,7 @@ func (x *MachineValidationResultList) String() string { func (*MachineValidationResultList) ProtoMessage() {} func (x *MachineValidationResultList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[487] + mi := &file_nico_nico_proto_msgTypes[489] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37475,7 +37566,7 @@ func (x *MachineValidationResultList) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationResultList.ProtoReflect.Descriptor instead. func (*MachineValidationResultList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{487} + return file_nico_nico_proto_rawDescGZIP(), []int{489} } func (x *MachineValidationResultList) GetResults() []*MachineValidationResult { @@ -37496,7 +37587,7 @@ type MachineValidationGetRequest struct { func (x *MachineValidationGetRequest) Reset() { *x = MachineValidationGetRequest{} - mi := &file_nico_nico_proto_msgTypes[488] + mi := &file_nico_nico_proto_msgTypes[490] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37508,7 +37599,7 @@ func (x *MachineValidationGetRequest) String() string { func (*MachineValidationGetRequest) ProtoMessage() {} func (x *MachineValidationGetRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[488] + mi := &file_nico_nico_proto_msgTypes[490] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37521,7 +37612,7 @@ func (x *MachineValidationGetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationGetRequest.ProtoReflect.Descriptor instead. func (*MachineValidationGetRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{488} + return file_nico_nico_proto_rawDescGZIP(), []int{490} } func (x *MachineValidationGetRequest) GetMachineId() *MachineId { @@ -37561,7 +37652,7 @@ type MachineValidationStatus struct { func (x *MachineValidationStatus) Reset() { *x = MachineValidationStatus{} - mi := &file_nico_nico_proto_msgTypes[489] + mi := &file_nico_nico_proto_msgTypes[491] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37573,7 +37664,7 @@ func (x *MachineValidationStatus) String() string { func (*MachineValidationStatus) ProtoMessage() {} func (x *MachineValidationStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[489] + mi := &file_nico_nico_proto_msgTypes[491] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37586,7 +37677,7 @@ func (x *MachineValidationStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationStatus.ProtoReflect.Descriptor instead. func (*MachineValidationStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{489} + return file_nico_nico_proto_rawDescGZIP(), []int{491} } func (x *MachineValidationStatus) GetMachineValidationState() isMachineValidationStatus_MachineValidationState { @@ -37676,7 +37767,7 @@ type MachineValidationRun struct { func (x *MachineValidationRun) Reset() { *x = MachineValidationRun{} - mi := &file_nico_nico_proto_msgTypes[490] + mi := &file_nico_nico_proto_msgTypes[492] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37688,7 +37779,7 @@ func (x *MachineValidationRun) String() string { func (*MachineValidationRun) ProtoMessage() {} func (x *MachineValidationRun) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[490] + mi := &file_nico_nico_proto_msgTypes[492] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37701,7 +37792,7 @@ func (x *MachineValidationRun) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRun.ProtoReflect.Descriptor instead. func (*MachineValidationRun) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{490} + return file_nico_nico_proto_rawDescGZIP(), []int{492} } func (x *MachineValidationRun) GetValidationId() *MachineValidationId { @@ -37777,7 +37868,7 @@ type MachineSetAutoUpdateRequest struct { func (x *MachineSetAutoUpdateRequest) Reset() { *x = MachineSetAutoUpdateRequest{} - mi := &file_nico_nico_proto_msgTypes[491] + mi := &file_nico_nico_proto_msgTypes[493] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37789,7 +37880,7 @@ func (x *MachineSetAutoUpdateRequest) String() string { func (*MachineSetAutoUpdateRequest) ProtoMessage() {} func (x *MachineSetAutoUpdateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[491] + mi := &file_nico_nico_proto_msgTypes[493] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37802,7 +37893,7 @@ func (x *MachineSetAutoUpdateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineSetAutoUpdateRequest.ProtoReflect.Descriptor instead. func (*MachineSetAutoUpdateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{491} + return file_nico_nico_proto_rawDescGZIP(), []int{493} } func (x *MachineSetAutoUpdateRequest) GetMachineId() *MachineId { @@ -37827,7 +37918,7 @@ type MachineSetAutoUpdateResponse struct { func (x *MachineSetAutoUpdateResponse) Reset() { *x = MachineSetAutoUpdateResponse{} - mi := &file_nico_nico_proto_msgTypes[492] + mi := &file_nico_nico_proto_msgTypes[494] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37839,7 +37930,7 @@ func (x *MachineSetAutoUpdateResponse) String() string { func (*MachineSetAutoUpdateResponse) ProtoMessage() {} func (x *MachineSetAutoUpdateResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[492] + mi := &file_nico_nico_proto_msgTypes[494] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37852,7 +37943,7 @@ func (x *MachineSetAutoUpdateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineSetAutoUpdateResponse.ProtoReflect.Descriptor instead. func (*MachineSetAutoUpdateResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{492} + return file_nico_nico_proto_rawDescGZIP(), []int{494} } type GetMachineValidationExternalConfigRequest struct { @@ -37864,7 +37955,7 @@ type GetMachineValidationExternalConfigRequest struct { func (x *GetMachineValidationExternalConfigRequest) Reset() { *x = GetMachineValidationExternalConfigRequest{} - mi := &file_nico_nico_proto_msgTypes[493] + mi := &file_nico_nico_proto_msgTypes[495] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37876,7 +37967,7 @@ func (x *GetMachineValidationExternalConfigRequest) String() string { func (*GetMachineValidationExternalConfigRequest) ProtoMessage() {} func (x *GetMachineValidationExternalConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[493] + mi := &file_nico_nico_proto_msgTypes[495] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37889,7 +37980,7 @@ func (x *GetMachineValidationExternalConfigRequest) ProtoReflect() protoreflect. // Deprecated: Use GetMachineValidationExternalConfigRequest.ProtoReflect.Descriptor instead. func (*GetMachineValidationExternalConfigRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{493} + return file_nico_nico_proto_rawDescGZIP(), []int{495} } func (x *GetMachineValidationExternalConfigRequest) GetName() string { @@ -37912,7 +38003,7 @@ type MachineValidationExternalConfig struct { func (x *MachineValidationExternalConfig) Reset() { *x = MachineValidationExternalConfig{} - mi := &file_nico_nico_proto_msgTypes[494] + mi := &file_nico_nico_proto_msgTypes[496] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37924,7 +38015,7 @@ func (x *MachineValidationExternalConfig) String() string { func (*MachineValidationExternalConfig) ProtoMessage() {} func (x *MachineValidationExternalConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[494] + mi := &file_nico_nico_proto_msgTypes[496] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -37937,7 +38028,7 @@ func (x *MachineValidationExternalConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationExternalConfig.ProtoReflect.Descriptor instead. func (*MachineValidationExternalConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{494} + return file_nico_nico_proto_rawDescGZIP(), []int{496} } func (x *MachineValidationExternalConfig) GetName() string { @@ -37984,7 +38075,7 @@ type GetMachineValidationExternalConfigResponse struct { func (x *GetMachineValidationExternalConfigResponse) Reset() { *x = GetMachineValidationExternalConfigResponse{} - mi := &file_nico_nico_proto_msgTypes[495] + mi := &file_nico_nico_proto_msgTypes[497] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -37996,7 +38087,7 @@ func (x *GetMachineValidationExternalConfigResponse) String() string { func (*GetMachineValidationExternalConfigResponse) ProtoMessage() {} func (x *GetMachineValidationExternalConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[495] + mi := &file_nico_nico_proto_msgTypes[497] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38009,7 +38100,7 @@ func (x *GetMachineValidationExternalConfigResponse) ProtoReflect() protoreflect // Deprecated: Use GetMachineValidationExternalConfigResponse.ProtoReflect.Descriptor instead. func (*GetMachineValidationExternalConfigResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{495} + return file_nico_nico_proto_rawDescGZIP(), []int{497} } func (x *GetMachineValidationExternalConfigResponse) GetConfig() *MachineValidationExternalConfig { @@ -38028,7 +38119,7 @@ type GetMachineValidationExternalConfigsRequest struct { func (x *GetMachineValidationExternalConfigsRequest) Reset() { *x = GetMachineValidationExternalConfigsRequest{} - mi := &file_nico_nico_proto_msgTypes[496] + mi := &file_nico_nico_proto_msgTypes[498] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38040,7 +38131,7 @@ func (x *GetMachineValidationExternalConfigsRequest) String() string { func (*GetMachineValidationExternalConfigsRequest) ProtoMessage() {} func (x *GetMachineValidationExternalConfigsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[496] + mi := &file_nico_nico_proto_msgTypes[498] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38053,7 +38144,7 @@ func (x *GetMachineValidationExternalConfigsRequest) ProtoReflect() protoreflect // Deprecated: Use GetMachineValidationExternalConfigsRequest.ProtoReflect.Descriptor instead. func (*GetMachineValidationExternalConfigsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{496} + return file_nico_nico_proto_rawDescGZIP(), []int{498} } func (x *GetMachineValidationExternalConfigsRequest) GetNames() []string { @@ -38072,7 +38163,7 @@ type GetMachineValidationExternalConfigsResponse struct { func (x *GetMachineValidationExternalConfigsResponse) Reset() { *x = GetMachineValidationExternalConfigsResponse{} - mi := &file_nico_nico_proto_msgTypes[497] + mi := &file_nico_nico_proto_msgTypes[499] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38084,7 +38175,7 @@ func (x *GetMachineValidationExternalConfigsResponse) String() string { func (*GetMachineValidationExternalConfigsResponse) ProtoMessage() {} func (x *GetMachineValidationExternalConfigsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[497] + mi := &file_nico_nico_proto_msgTypes[499] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38097,7 +38188,7 @@ func (x *GetMachineValidationExternalConfigsResponse) ProtoReflect() protoreflec // Deprecated: Use GetMachineValidationExternalConfigsResponse.ProtoReflect.Descriptor instead. func (*GetMachineValidationExternalConfigsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{497} + return file_nico_nico_proto_rawDescGZIP(), []int{499} } func (x *GetMachineValidationExternalConfigsResponse) GetConfigs() []*MachineValidationExternalConfig { @@ -38118,7 +38209,7 @@ type AddUpdateMachineValidationExternalConfigRequest struct { func (x *AddUpdateMachineValidationExternalConfigRequest) Reset() { *x = AddUpdateMachineValidationExternalConfigRequest{} - mi := &file_nico_nico_proto_msgTypes[498] + mi := &file_nico_nico_proto_msgTypes[500] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38130,7 +38221,7 @@ func (x *AddUpdateMachineValidationExternalConfigRequest) String() string { func (*AddUpdateMachineValidationExternalConfigRequest) ProtoMessage() {} func (x *AddUpdateMachineValidationExternalConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[498] + mi := &file_nico_nico_proto_msgTypes[500] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38143,7 +38234,7 @@ func (x *AddUpdateMachineValidationExternalConfigRequest) ProtoReflect() protore // Deprecated: Use AddUpdateMachineValidationExternalConfigRequest.ProtoReflect.Descriptor instead. func (*AddUpdateMachineValidationExternalConfigRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{498} + return file_nico_nico_proto_rawDescGZIP(), []int{500} } func (x *AddUpdateMachineValidationExternalConfigRequest) GetName() string { @@ -38176,7 +38267,7 @@ type RemoveMachineValidationExternalConfigRequest struct { func (x *RemoveMachineValidationExternalConfigRequest) Reset() { *x = RemoveMachineValidationExternalConfigRequest{} - mi := &file_nico_nico_proto_msgTypes[499] + mi := &file_nico_nico_proto_msgTypes[501] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38188,7 +38279,7 @@ func (x *RemoveMachineValidationExternalConfigRequest) String() string { func (*RemoveMachineValidationExternalConfigRequest) ProtoMessage() {} func (x *RemoveMachineValidationExternalConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[499] + mi := &file_nico_nico_proto_msgTypes[501] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38201,7 +38292,7 @@ func (x *RemoveMachineValidationExternalConfigRequest) ProtoReflect() protorefle // Deprecated: Use RemoveMachineValidationExternalConfigRequest.ProtoReflect.Descriptor instead. func (*RemoveMachineValidationExternalConfigRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{499} + return file_nico_nico_proto_rawDescGZIP(), []int{501} } func (x *RemoveMachineValidationExternalConfigRequest) GetName() string { @@ -38225,7 +38316,7 @@ type MachineValidationOnDemandRequest struct { func (x *MachineValidationOnDemandRequest) Reset() { *x = MachineValidationOnDemandRequest{} - mi := &file_nico_nico_proto_msgTypes[500] + mi := &file_nico_nico_proto_msgTypes[502] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38237,7 +38328,7 @@ func (x *MachineValidationOnDemandRequest) String() string { func (*MachineValidationOnDemandRequest) ProtoMessage() {} func (x *MachineValidationOnDemandRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[500] + mi := &file_nico_nico_proto_msgTypes[502] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38250,7 +38341,7 @@ func (x *MachineValidationOnDemandRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationOnDemandRequest.ProtoReflect.Descriptor instead. func (*MachineValidationOnDemandRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{500} + return file_nico_nico_proto_rawDescGZIP(), []int{502} } func (x *MachineValidationOnDemandRequest) GetMachineId() *MachineId { @@ -38304,7 +38395,7 @@ type MachineValidationOnDemandResponse struct { func (x *MachineValidationOnDemandResponse) Reset() { *x = MachineValidationOnDemandResponse{} - mi := &file_nico_nico_proto_msgTypes[501] + mi := &file_nico_nico_proto_msgTypes[503] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38316,7 +38407,7 @@ func (x *MachineValidationOnDemandResponse) String() string { func (*MachineValidationOnDemandResponse) ProtoMessage() {} func (x *MachineValidationOnDemandResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[501] + mi := &file_nico_nico_proto_msgTypes[503] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38329,7 +38420,7 @@ func (x *MachineValidationOnDemandResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationOnDemandResponse.ProtoReflect.Descriptor instead. func (*MachineValidationOnDemandResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{501} + return file_nico_nico_proto_rawDescGZIP(), []int{503} } func (x *MachineValidationOnDemandResponse) GetValidationId() *MachineValidationId { @@ -38359,7 +38450,7 @@ type FirmwareUpgradeActivity struct { func (x *FirmwareUpgradeActivity) Reset() { *x = FirmwareUpgradeActivity{} - mi := &file_nico_nico_proto_msgTypes[502] + mi := &file_nico_nico_proto_msgTypes[504] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38371,7 +38462,7 @@ func (x *FirmwareUpgradeActivity) String() string { func (*FirmwareUpgradeActivity) ProtoMessage() {} func (x *FirmwareUpgradeActivity) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[502] + mi := &file_nico_nico_proto_msgTypes[504] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38384,7 +38475,7 @@ func (x *FirmwareUpgradeActivity) ProtoReflect() protoreflect.Message { // Deprecated: Use FirmwareUpgradeActivity.ProtoReflect.Descriptor instead. func (*FirmwareUpgradeActivity) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{502} + return file_nico_nico_proto_rawDescGZIP(), []int{504} } func (x *FirmwareUpgradeActivity) GetFirmwareVersion() string { @@ -38430,7 +38521,7 @@ type NvosUpdateActivity struct { func (x *NvosUpdateActivity) Reset() { *x = NvosUpdateActivity{} - mi := &file_nico_nico_proto_msgTypes[503] + mi := &file_nico_nico_proto_msgTypes[505] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38442,7 +38533,7 @@ func (x *NvosUpdateActivity) String() string { func (*NvosUpdateActivity) ProtoMessage() {} func (x *NvosUpdateActivity) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[503] + mi := &file_nico_nico_proto_msgTypes[505] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38455,7 +38546,7 @@ func (x *NvosUpdateActivity) ProtoReflect() protoreflect.Message { // Deprecated: Use NvosUpdateActivity.ProtoReflect.Descriptor instead. func (*NvosUpdateActivity) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{503} + return file_nico_nico_proto_rawDescGZIP(), []int{505} } func (x *NvosUpdateActivity) GetConfigJson() string { @@ -38480,7 +38571,7 @@ type ConfigureNmxClusterActivity struct { func (x *ConfigureNmxClusterActivity) Reset() { *x = ConfigureNmxClusterActivity{} - mi := &file_nico_nico_proto_msgTypes[504] + mi := &file_nico_nico_proto_msgTypes[506] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38492,7 +38583,7 @@ func (x *ConfigureNmxClusterActivity) String() string { func (*ConfigureNmxClusterActivity) ProtoMessage() {} func (x *ConfigureNmxClusterActivity) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[504] + mi := &file_nico_nico_proto_msgTypes[506] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38505,7 +38596,7 @@ func (x *ConfigureNmxClusterActivity) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureNmxClusterActivity.ProtoReflect.Descriptor instead. func (*ConfigureNmxClusterActivity) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{504} + return file_nico_nico_proto_rawDescGZIP(), []int{506} } type PowerSequenceActivity struct { @@ -38516,7 +38607,7 @@ type PowerSequenceActivity struct { func (x *PowerSequenceActivity) Reset() { *x = PowerSequenceActivity{} - mi := &file_nico_nico_proto_msgTypes[505] + mi := &file_nico_nico_proto_msgTypes[507] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38528,7 +38619,7 @@ func (x *PowerSequenceActivity) String() string { func (*PowerSequenceActivity) ProtoMessage() {} func (x *PowerSequenceActivity) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[505] + mi := &file_nico_nico_proto_msgTypes[507] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38541,7 +38632,7 @@ func (x *PowerSequenceActivity) ProtoReflect() protoreflect.Message { // Deprecated: Use PowerSequenceActivity.ProtoReflect.Descriptor instead. func (*PowerSequenceActivity) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{505} + return file_nico_nico_proto_rawDescGZIP(), []int{507} } // A single maintenance activity with its per-activity configuration. @@ -38561,7 +38652,7 @@ type MaintenanceActivityConfig struct { func (x *MaintenanceActivityConfig) Reset() { *x = MaintenanceActivityConfig{} - mi := &file_nico_nico_proto_msgTypes[506] + mi := &file_nico_nico_proto_msgTypes[508] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38573,7 +38664,7 @@ func (x *MaintenanceActivityConfig) String() string { func (*MaintenanceActivityConfig) ProtoMessage() {} func (x *MaintenanceActivityConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[506] + mi := &file_nico_nico_proto_msgTypes[508] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38586,7 +38677,7 @@ func (x *MaintenanceActivityConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use MaintenanceActivityConfig.ProtoReflect.Descriptor instead. func (*MaintenanceActivityConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{506} + return file_nico_nico_proto_rawDescGZIP(), []int{508} } func (x *MaintenanceActivityConfig) GetActivity() isMaintenanceActivityConfig_Activity { @@ -38677,7 +38768,7 @@ type RackMaintenanceScope struct { func (x *RackMaintenanceScope) Reset() { *x = RackMaintenanceScope{} - mi := &file_nico_nico_proto_msgTypes[507] + mi := &file_nico_nico_proto_msgTypes[509] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38689,7 +38780,7 @@ func (x *RackMaintenanceScope) String() string { func (*RackMaintenanceScope) ProtoMessage() {} func (x *RackMaintenanceScope) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[507] + mi := &file_nico_nico_proto_msgTypes[509] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38702,7 +38793,7 @@ func (x *RackMaintenanceScope) ProtoReflect() protoreflect.Message { // Deprecated: Use RackMaintenanceScope.ProtoReflect.Descriptor instead. func (*RackMaintenanceScope) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{507} + return file_nico_nico_proto_rawDescGZIP(), []int{509} } func (x *RackMaintenanceScope) GetMachineIds() []string { @@ -38746,7 +38837,7 @@ type RackMaintenanceOnDemandRequest struct { func (x *RackMaintenanceOnDemandRequest) Reset() { *x = RackMaintenanceOnDemandRequest{} - mi := &file_nico_nico_proto_msgTypes[508] + mi := &file_nico_nico_proto_msgTypes[510] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38758,7 +38849,7 @@ func (x *RackMaintenanceOnDemandRequest) String() string { func (*RackMaintenanceOnDemandRequest) ProtoMessage() {} func (x *RackMaintenanceOnDemandRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[508] + mi := &file_nico_nico_proto_msgTypes[510] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38771,7 +38862,7 @@ func (x *RackMaintenanceOnDemandRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RackMaintenanceOnDemandRequest.ProtoReflect.Descriptor instead. func (*RackMaintenanceOnDemandRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{508} + return file_nico_nico_proto_rawDescGZIP(), []int{510} } func (x *RackMaintenanceOnDemandRequest) GetRackId() *RackId { @@ -38796,7 +38887,7 @@ type RackMaintenanceOnDemandResponse struct { func (x *RackMaintenanceOnDemandResponse) Reset() { *x = RackMaintenanceOnDemandResponse{} - mi := &file_nico_nico_proto_msgTypes[509] + mi := &file_nico_nico_proto_msgTypes[511] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38808,7 +38899,7 @@ func (x *RackMaintenanceOnDemandResponse) String() string { func (*RackMaintenanceOnDemandResponse) ProtoMessage() {} func (x *RackMaintenanceOnDemandResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[509] + mi := &file_nico_nico_proto_msgTypes[511] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38821,7 +38912,7 @@ func (x *RackMaintenanceOnDemandResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RackMaintenanceOnDemandResponse.ProtoReflect.Descriptor instead. func (*RackMaintenanceOnDemandResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{509} + return file_nico_nico_proto_rawDescGZIP(), []int{511} } type AdminPowerControlRequest struct { @@ -38835,7 +38926,7 @@ type AdminPowerControlRequest struct { func (x *AdminPowerControlRequest) Reset() { *x = AdminPowerControlRequest{} - mi := &file_nico_nico_proto_msgTypes[510] + mi := &file_nico_nico_proto_msgTypes[512] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38847,7 +38938,7 @@ func (x *AdminPowerControlRequest) String() string { func (*AdminPowerControlRequest) ProtoMessage() {} func (x *AdminPowerControlRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[510] + mi := &file_nico_nico_proto_msgTypes[512] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38860,7 +38951,7 @@ func (x *AdminPowerControlRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AdminPowerControlRequest.ProtoReflect.Descriptor instead. func (*AdminPowerControlRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{510} + return file_nico_nico_proto_rawDescGZIP(), []int{512} } func (x *AdminPowerControlRequest) GetBmcEndpointRequest() *BmcEndpointRequest { @@ -38893,7 +38984,7 @@ type AdminPowerControlResponse struct { func (x *AdminPowerControlResponse) Reset() { *x = AdminPowerControlResponse{} - mi := &file_nico_nico_proto_msgTypes[511] + mi := &file_nico_nico_proto_msgTypes[513] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38905,7 +38996,7 @@ func (x *AdminPowerControlResponse) String() string { func (*AdminPowerControlResponse) ProtoMessage() {} func (x *AdminPowerControlResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[511] + mi := &file_nico_nico_proto_msgTypes[513] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38918,7 +39009,7 @@ func (x *AdminPowerControlResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AdminPowerControlResponse.ProtoReflect.Descriptor instead. func (*AdminPowerControlResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{511} + return file_nico_nico_proto_rawDescGZIP(), []int{513} } func (x *AdminPowerControlResponse) GetMsg() string { @@ -38938,7 +39029,7 @@ type GetRedfishJobStateRequest struct { func (x *GetRedfishJobStateRequest) Reset() { *x = GetRedfishJobStateRequest{} - mi := &file_nico_nico_proto_msgTypes[512] + mi := &file_nico_nico_proto_msgTypes[514] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -38950,7 +39041,7 @@ func (x *GetRedfishJobStateRequest) String() string { func (*GetRedfishJobStateRequest) ProtoMessage() {} func (x *GetRedfishJobStateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[512] + mi := &file_nico_nico_proto_msgTypes[514] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -38963,7 +39054,7 @@ func (x *GetRedfishJobStateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRedfishJobStateRequest.ProtoReflect.Descriptor instead. func (*GetRedfishJobStateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{512} + return file_nico_nico_proto_rawDescGZIP(), []int{514} } func (x *GetRedfishJobStateRequest) GetMachineId() *MachineId { @@ -38989,7 +39080,7 @@ type GetRedfishJobStateResponse struct { func (x *GetRedfishJobStateResponse) Reset() { *x = GetRedfishJobStateResponse{} - mi := &file_nico_nico_proto_msgTypes[513] + mi := &file_nico_nico_proto_msgTypes[515] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39001,7 +39092,7 @@ func (x *GetRedfishJobStateResponse) String() string { func (*GetRedfishJobStateResponse) ProtoMessage() {} func (x *GetRedfishJobStateResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[513] + mi := &file_nico_nico_proto_msgTypes[515] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39014,7 +39105,7 @@ func (x *GetRedfishJobStateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRedfishJobStateResponse.ProtoReflect.Descriptor instead. func (*GetRedfishJobStateResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{513} + return file_nico_nico_proto_rawDescGZIP(), []int{515} } func (x *GetRedfishJobStateResponse) GetJobState() GetRedfishJobStateResponse_RedfishJobState { @@ -39033,7 +39124,7 @@ type MachineValidationRunList struct { func (x *MachineValidationRunList) Reset() { *x = MachineValidationRunList{} - mi := &file_nico_nico_proto_msgTypes[514] + mi := &file_nico_nico_proto_msgTypes[516] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39045,7 +39136,7 @@ func (x *MachineValidationRunList) String() string { func (*MachineValidationRunList) ProtoMessage() {} func (x *MachineValidationRunList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[514] + mi := &file_nico_nico_proto_msgTypes[516] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39058,7 +39149,7 @@ func (x *MachineValidationRunList) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRunList.ProtoReflect.Descriptor instead. func (*MachineValidationRunList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{514} + return file_nico_nico_proto_rawDescGZIP(), []int{516} } func (x *MachineValidationRunList) GetRuns() []*MachineValidationRun { @@ -39078,7 +39169,7 @@ type MachineValidationRunListGetRequest struct { func (x *MachineValidationRunListGetRequest) Reset() { *x = MachineValidationRunListGetRequest{} - mi := &file_nico_nico_proto_msgTypes[515] + mi := &file_nico_nico_proto_msgTypes[517] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39090,7 +39181,7 @@ func (x *MachineValidationRunListGetRequest) String() string { func (*MachineValidationRunListGetRequest) ProtoMessage() {} func (x *MachineValidationRunListGetRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[515] + mi := &file_nico_nico_proto_msgTypes[517] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39103,7 +39194,7 @@ func (x *MachineValidationRunListGetRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationRunListGetRequest.ProtoReflect.Descriptor instead. func (*MachineValidationRunListGetRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{515} + return file_nico_nico_proto_rawDescGZIP(), []int{517} } func (x *MachineValidationRunListGetRequest) GetMachineId() *MachineId { @@ -39129,7 +39220,7 @@ type MachineValidationRunItemSearchFilter struct { func (x *MachineValidationRunItemSearchFilter) Reset() { *x = MachineValidationRunItemSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[516] + mi := &file_nico_nico_proto_msgTypes[518] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39141,7 +39232,7 @@ func (x *MachineValidationRunItemSearchFilter) String() string { func (*MachineValidationRunItemSearchFilter) ProtoMessage() {} func (x *MachineValidationRunItemSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[516] + mi := &file_nico_nico_proto_msgTypes[518] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39154,7 +39245,7 @@ func (x *MachineValidationRunItemSearchFilter) ProtoReflect() protoreflect.Messa // Deprecated: Use MachineValidationRunItemSearchFilter.ProtoReflect.Descriptor instead. func (*MachineValidationRunItemSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{516} + return file_nico_nico_proto_rawDescGZIP(), []int{518} } func (x *MachineValidationRunItemSearchFilter) GetValidationId() *MachineValidationId { @@ -39173,7 +39264,7 @@ type MachineValidationRunItemIdList struct { func (x *MachineValidationRunItemIdList) Reset() { *x = MachineValidationRunItemIdList{} - mi := &file_nico_nico_proto_msgTypes[517] + mi := &file_nico_nico_proto_msgTypes[519] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39185,7 +39276,7 @@ func (x *MachineValidationRunItemIdList) String() string { func (*MachineValidationRunItemIdList) ProtoMessage() {} func (x *MachineValidationRunItemIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[517] + mi := &file_nico_nico_proto_msgTypes[519] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39198,7 +39289,7 @@ func (x *MachineValidationRunItemIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRunItemIdList.ProtoReflect.Descriptor instead. func (*MachineValidationRunItemIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{517} + return file_nico_nico_proto_rawDescGZIP(), []int{519} } func (x *MachineValidationRunItemIdList) GetRunItemIds() []*UUID { @@ -39217,7 +39308,7 @@ type MachineValidationRunItemsByIdsRequest struct { func (x *MachineValidationRunItemsByIdsRequest) Reset() { *x = MachineValidationRunItemsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[518] + mi := &file_nico_nico_proto_msgTypes[520] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39229,7 +39320,7 @@ func (x *MachineValidationRunItemsByIdsRequest) String() string { func (*MachineValidationRunItemsByIdsRequest) ProtoMessage() {} func (x *MachineValidationRunItemsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[518] + mi := &file_nico_nico_proto_msgTypes[520] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39242,7 +39333,7 @@ func (x *MachineValidationRunItemsByIdsRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use MachineValidationRunItemsByIdsRequest.ProtoReflect.Descriptor instead. func (*MachineValidationRunItemsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{518} + return file_nico_nico_proto_rawDescGZIP(), []int{520} } func (x *MachineValidationRunItemsByIdsRequest) GetRunItemIds() []*UUID { @@ -39261,7 +39352,7 @@ type MachineValidationRunItemList struct { func (x *MachineValidationRunItemList) Reset() { *x = MachineValidationRunItemList{} - mi := &file_nico_nico_proto_msgTypes[519] + mi := &file_nico_nico_proto_msgTypes[521] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39273,7 +39364,7 @@ func (x *MachineValidationRunItemList) String() string { func (*MachineValidationRunItemList) ProtoMessage() {} func (x *MachineValidationRunItemList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[519] + mi := &file_nico_nico_proto_msgTypes[521] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39286,7 +39377,7 @@ func (x *MachineValidationRunItemList) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRunItemList.ProtoReflect.Descriptor instead. func (*MachineValidationRunItemList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{519} + return file_nico_nico_proto_rawDescGZIP(), []int{521} } func (x *MachineValidationRunItemList) GetRunItems() []*MachineValidationRunItem { @@ -39322,7 +39413,7 @@ type MachineValidationRunItem struct { func (x *MachineValidationRunItem) Reset() { *x = MachineValidationRunItem{} - mi := &file_nico_nico_proto_msgTypes[520] + mi := &file_nico_nico_proto_msgTypes[522] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39334,7 +39425,7 @@ func (x *MachineValidationRunItem) String() string { func (*MachineValidationRunItem) ProtoMessage() {} func (x *MachineValidationRunItem) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[520] + mi := &file_nico_nico_proto_msgTypes[522] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39347,7 +39438,7 @@ func (x *MachineValidationRunItem) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRunItem.ProtoReflect.Descriptor instead. func (*MachineValidationRunItem) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{520} + return file_nico_nico_proto_rawDescGZIP(), []int{522} } func (x *MachineValidationRunItem) GetRunItemId() *UUID { @@ -39485,7 +39576,7 @@ type MachineValidationAttemptGetRequest struct { func (x *MachineValidationAttemptGetRequest) Reset() { *x = MachineValidationAttemptGetRequest{} - mi := &file_nico_nico_proto_msgTypes[521] + mi := &file_nico_nico_proto_msgTypes[523] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39497,7 +39588,7 @@ func (x *MachineValidationAttemptGetRequest) String() string { func (*MachineValidationAttemptGetRequest) ProtoMessage() {} func (x *MachineValidationAttemptGetRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[521] + mi := &file_nico_nico_proto_msgTypes[523] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39510,7 +39601,7 @@ func (x *MachineValidationAttemptGetRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationAttemptGetRequest.ProtoReflect.Descriptor instead. func (*MachineValidationAttemptGetRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{521} + return file_nico_nico_proto_rawDescGZIP(), []int{523} } func (x *MachineValidationAttemptGetRequest) GetAttemptId() *UUID { @@ -39543,7 +39634,7 @@ type MachineValidationAttempt struct { func (x *MachineValidationAttempt) Reset() { *x = MachineValidationAttempt{} - mi := &file_nico_nico_proto_msgTypes[522] + mi := &file_nico_nico_proto_msgTypes[524] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39555,7 +39646,7 @@ func (x *MachineValidationAttempt) String() string { func (*MachineValidationAttempt) ProtoMessage() {} func (x *MachineValidationAttempt) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[522] + mi := &file_nico_nico_proto_msgTypes[524] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39568,7 +39659,7 @@ func (x *MachineValidationAttempt) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationAttempt.ProtoReflect.Descriptor instead. func (*MachineValidationAttempt) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{522} + return file_nico_nico_proto_rawDescGZIP(), []int{524} } func (x *MachineValidationAttempt) GetAttemptId() *UUID { @@ -39691,7 +39782,7 @@ type MachineValidationHeartbeatRequest struct { func (x *MachineValidationHeartbeatRequest) Reset() { *x = MachineValidationHeartbeatRequest{} - mi := &file_nico_nico_proto_msgTypes[523] + mi := &file_nico_nico_proto_msgTypes[525] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39703,7 +39794,7 @@ func (x *MachineValidationHeartbeatRequest) String() string { func (*MachineValidationHeartbeatRequest) ProtoMessage() {} func (x *MachineValidationHeartbeatRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[523] + mi := &file_nico_nico_proto_msgTypes[525] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39716,7 +39807,7 @@ func (x *MachineValidationHeartbeatRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationHeartbeatRequest.ProtoReflect.Descriptor instead. func (*MachineValidationHeartbeatRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{523} + return file_nico_nico_proto_rawDescGZIP(), []int{525} } func (x *MachineValidationHeartbeatRequest) GetValidationId() *MachineValidationId { @@ -39791,7 +39882,7 @@ type MachineValidationHeartbeatResponse struct { func (x *MachineValidationHeartbeatResponse) Reset() { *x = MachineValidationHeartbeatResponse{} - mi := &file_nico_nico_proto_msgTypes[524] + mi := &file_nico_nico_proto_msgTypes[526] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39803,7 +39894,7 @@ func (x *MachineValidationHeartbeatResponse) String() string { func (*MachineValidationHeartbeatResponse) ProtoMessage() {} func (x *MachineValidationHeartbeatResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[524] + mi := &file_nico_nico_proto_msgTypes[526] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39816,7 +39907,7 @@ func (x *MachineValidationHeartbeatResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationHeartbeatResponse.ProtoReflect.Descriptor instead. func (*MachineValidationHeartbeatResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{524} + return file_nico_nico_proto_rawDescGZIP(), []int{526} } func (x *MachineValidationHeartbeatResponse) GetAccepted() bool { @@ -39835,7 +39926,7 @@ type IsBmcInManagedHostResponse struct { func (x *IsBmcInManagedHostResponse) Reset() { *x = IsBmcInManagedHostResponse{} - mi := &file_nico_nico_proto_msgTypes[525] + mi := &file_nico_nico_proto_msgTypes[527] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39847,7 +39938,7 @@ func (x *IsBmcInManagedHostResponse) String() string { func (*IsBmcInManagedHostResponse) ProtoMessage() {} func (x *IsBmcInManagedHostResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[525] + mi := &file_nico_nico_proto_msgTypes[527] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39860,7 +39951,7 @@ func (x *IsBmcInManagedHostResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use IsBmcInManagedHostResponse.ProtoReflect.Descriptor instead. func (*IsBmcInManagedHostResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{525} + return file_nico_nico_proto_rawDescGZIP(), []int{527} } func (x *IsBmcInManagedHostResponse) GetInManagedHost() bool { @@ -39879,7 +39970,7 @@ type BmcCredentialStatusResponse struct { func (x *BmcCredentialStatusResponse) Reset() { *x = BmcCredentialStatusResponse{} - mi := &file_nico_nico_proto_msgTypes[526] + mi := &file_nico_nico_proto_msgTypes[528] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39891,7 +39982,7 @@ func (x *BmcCredentialStatusResponse) String() string { func (*BmcCredentialStatusResponse) ProtoMessage() {} func (x *BmcCredentialStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[526] + mi := &file_nico_nico_proto_msgTypes[528] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39904,7 +39995,7 @@ func (x *BmcCredentialStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BmcCredentialStatusResponse.ProtoReflect.Descriptor instead. func (*BmcCredentialStatusResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{526} + return file_nico_nico_proto_rawDescGZIP(), []int{528} } func (x *BmcCredentialStatusResponse) GetHaveCredentials() bool { @@ -39930,7 +40021,7 @@ type MachineValidationTestsGetRequest struct { func (x *MachineValidationTestsGetRequest) Reset() { *x = MachineValidationTestsGetRequest{} - mi := &file_nico_nico_proto_msgTypes[527] + mi := &file_nico_nico_proto_msgTypes[529] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -39942,7 +40033,7 @@ func (x *MachineValidationTestsGetRequest) String() string { func (*MachineValidationTestsGetRequest) ProtoMessage() {} func (x *MachineValidationTestsGetRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[527] + mi := &file_nico_nico_proto_msgTypes[529] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -39955,7 +40046,7 @@ func (x *MachineValidationTestsGetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationTestsGetRequest.ProtoReflect.Descriptor instead. func (*MachineValidationTestsGetRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{527} + return file_nico_nico_proto_rawDescGZIP(), []int{529} } func (x *MachineValidationTestsGetRequest) GetSupportedPlatforms() []string { @@ -40025,7 +40116,7 @@ type MachineValidationTestUpdateRequest struct { func (x *MachineValidationTestUpdateRequest) Reset() { *x = MachineValidationTestUpdateRequest{} - mi := &file_nico_nico_proto_msgTypes[528] + mi := &file_nico_nico_proto_msgTypes[530] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40037,7 +40128,7 @@ func (x *MachineValidationTestUpdateRequest) String() string { func (*MachineValidationTestUpdateRequest) ProtoMessage() {} func (x *MachineValidationTestUpdateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[528] + mi := &file_nico_nico_proto_msgTypes[530] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40050,7 +40141,7 @@ func (x *MachineValidationTestUpdateRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationTestUpdateRequest.ProtoReflect.Descriptor instead. func (*MachineValidationTestUpdateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{528} + return file_nico_nico_proto_rawDescGZIP(), []int{530} } func (x *MachineValidationTestUpdateRequest) GetTestId() string { @@ -40100,7 +40191,7 @@ type MachineValidationTestAddRequest struct { func (x *MachineValidationTestAddRequest) Reset() { *x = MachineValidationTestAddRequest{} - mi := &file_nico_nico_proto_msgTypes[529] + mi := &file_nico_nico_proto_msgTypes[531] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40112,7 +40203,7 @@ func (x *MachineValidationTestAddRequest) String() string { func (*MachineValidationTestAddRequest) ProtoMessage() {} func (x *MachineValidationTestAddRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[529] + mi := &file_nico_nico_proto_msgTypes[531] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40125,7 +40216,7 @@ func (x *MachineValidationTestAddRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationTestAddRequest.ProtoReflect.Descriptor instead. func (*MachineValidationTestAddRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{529} + return file_nico_nico_proto_rawDescGZIP(), []int{531} } func (x *MachineValidationTestAddRequest) GetName() string { @@ -40264,7 +40355,7 @@ type MachineValidationTestAddUpdateResponse struct { func (x *MachineValidationTestAddUpdateResponse) Reset() { *x = MachineValidationTestAddUpdateResponse{} - mi := &file_nico_nico_proto_msgTypes[530] + mi := &file_nico_nico_proto_msgTypes[532] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40276,7 +40367,7 @@ func (x *MachineValidationTestAddUpdateResponse) String() string { func (*MachineValidationTestAddUpdateResponse) ProtoMessage() {} func (x *MachineValidationTestAddUpdateResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[530] + mi := &file_nico_nico_proto_msgTypes[532] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40289,7 +40380,7 @@ func (x *MachineValidationTestAddUpdateResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use MachineValidationTestAddUpdateResponse.ProtoReflect.Descriptor instead. func (*MachineValidationTestAddUpdateResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{530} + return file_nico_nico_proto_rawDescGZIP(), []int{532} } func (x *MachineValidationTestAddUpdateResponse) GetTestId() string { @@ -40315,7 +40406,7 @@ type MachineValidationTestsGetResponse struct { func (x *MachineValidationTestsGetResponse) Reset() { *x = MachineValidationTestsGetResponse{} - mi := &file_nico_nico_proto_msgTypes[531] + mi := &file_nico_nico_proto_msgTypes[533] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40327,7 +40418,7 @@ func (x *MachineValidationTestsGetResponse) String() string { func (*MachineValidationTestsGetResponse) ProtoMessage() {} func (x *MachineValidationTestsGetResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[531] + mi := &file_nico_nico_proto_msgTypes[533] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40340,7 +40431,7 @@ func (x *MachineValidationTestsGetResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MachineValidationTestsGetResponse.ProtoReflect.Descriptor instead. func (*MachineValidationTestsGetResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{531} + return file_nico_nico_proto_rawDescGZIP(), []int{533} } func (x *MachineValidationTestsGetResponse) GetTests() []*MachineValidationTest { @@ -40360,7 +40451,7 @@ type MachineValidationTestVerfiedRequest struct { func (x *MachineValidationTestVerfiedRequest) Reset() { *x = MachineValidationTestVerfiedRequest{} - mi := &file_nico_nico_proto_msgTypes[532] + mi := &file_nico_nico_proto_msgTypes[534] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40372,7 +40463,7 @@ func (x *MachineValidationTestVerfiedRequest) String() string { func (*MachineValidationTestVerfiedRequest) ProtoMessage() {} func (x *MachineValidationTestVerfiedRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[532] + mi := &file_nico_nico_proto_msgTypes[534] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40385,7 +40476,7 @@ func (x *MachineValidationTestVerfiedRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use MachineValidationTestVerfiedRequest.ProtoReflect.Descriptor instead. func (*MachineValidationTestVerfiedRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{532} + return file_nico_nico_proto_rawDescGZIP(), []int{534} } func (x *MachineValidationTestVerfiedRequest) GetTestId() string { @@ -40411,7 +40502,7 @@ type MachineValidationTestVerfiedResponse struct { func (x *MachineValidationTestVerfiedResponse) Reset() { *x = MachineValidationTestVerfiedResponse{} - mi := &file_nico_nico_proto_msgTypes[533] + mi := &file_nico_nico_proto_msgTypes[535] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40423,7 +40514,7 @@ func (x *MachineValidationTestVerfiedResponse) String() string { func (*MachineValidationTestVerfiedResponse) ProtoMessage() {} func (x *MachineValidationTestVerfiedResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[533] + mi := &file_nico_nico_proto_msgTypes[535] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40436,7 +40527,7 @@ func (x *MachineValidationTestVerfiedResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use MachineValidationTestVerfiedResponse.ProtoReflect.Descriptor instead. func (*MachineValidationTestVerfiedResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{533} + return file_nico_nico_proto_rawDescGZIP(), []int{535} } func (x *MachineValidationTestVerfiedResponse) GetMessage() string { @@ -40477,7 +40568,7 @@ type MachineValidationTest struct { func (x *MachineValidationTest) Reset() { *x = MachineValidationTest{} - mi := &file_nico_nico_proto_msgTypes[534] + mi := &file_nico_nico_proto_msgTypes[536] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40489,7 +40580,7 @@ func (x *MachineValidationTest) String() string { func (*MachineValidationTest) ProtoMessage() {} func (x *MachineValidationTest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[534] + mi := &file_nico_nico_proto_msgTypes[536] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40502,7 +40593,7 @@ func (x *MachineValidationTest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationTest.ProtoReflect.Descriptor instead. func (*MachineValidationTest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{534} + return file_nico_nico_proto_rawDescGZIP(), []int{536} } func (x *MachineValidationTest) GetTestId() string { @@ -40676,7 +40767,7 @@ type MachineValidationTestNextVersionResponse struct { func (x *MachineValidationTestNextVersionResponse) Reset() { *x = MachineValidationTestNextVersionResponse{} - mi := &file_nico_nico_proto_msgTypes[535] + mi := &file_nico_nico_proto_msgTypes[537] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40688,7 +40779,7 @@ func (x *MachineValidationTestNextVersionResponse) String() string { func (*MachineValidationTestNextVersionResponse) ProtoMessage() {} func (x *MachineValidationTestNextVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[535] + mi := &file_nico_nico_proto_msgTypes[537] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40701,7 +40792,7 @@ func (x *MachineValidationTestNextVersionResponse) ProtoReflect() protoreflect.M // Deprecated: Use MachineValidationTestNextVersionResponse.ProtoReflect.Descriptor instead. func (*MachineValidationTestNextVersionResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{535} + return file_nico_nico_proto_rawDescGZIP(), []int{537} } func (x *MachineValidationTestNextVersionResponse) GetTestId() string { @@ -40727,7 +40818,7 @@ type MachineValidationTestNextVersionRequest struct { func (x *MachineValidationTestNextVersionRequest) Reset() { *x = MachineValidationTestNextVersionRequest{} - mi := &file_nico_nico_proto_msgTypes[536] + mi := &file_nico_nico_proto_msgTypes[538] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40739,7 +40830,7 @@ func (x *MachineValidationTestNextVersionRequest) String() string { func (*MachineValidationTestNextVersionRequest) ProtoMessage() {} func (x *MachineValidationTestNextVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[536] + mi := &file_nico_nico_proto_msgTypes[538] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40752,7 +40843,7 @@ func (x *MachineValidationTestNextVersionRequest) ProtoReflect() protoreflect.Me // Deprecated: Use MachineValidationTestNextVersionRequest.ProtoReflect.Descriptor instead. func (*MachineValidationTestNextVersionRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{536} + return file_nico_nico_proto_rawDescGZIP(), []int{538} } func (x *MachineValidationTestNextVersionRequest) GetTestId() string { @@ -40773,7 +40864,7 @@ type MachineValidationTestEnableDisableTestRequest struct { func (x *MachineValidationTestEnableDisableTestRequest) Reset() { *x = MachineValidationTestEnableDisableTestRequest{} - mi := &file_nico_nico_proto_msgTypes[537] + mi := &file_nico_nico_proto_msgTypes[539] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40785,7 +40876,7 @@ func (x *MachineValidationTestEnableDisableTestRequest) String() string { func (*MachineValidationTestEnableDisableTestRequest) ProtoMessage() {} func (x *MachineValidationTestEnableDisableTestRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[537] + mi := &file_nico_nico_proto_msgTypes[539] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40798,7 +40889,7 @@ func (x *MachineValidationTestEnableDisableTestRequest) ProtoReflect() protorefl // Deprecated: Use MachineValidationTestEnableDisableTestRequest.ProtoReflect.Descriptor instead. func (*MachineValidationTestEnableDisableTestRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{537} + return file_nico_nico_proto_rawDescGZIP(), []int{539} } func (x *MachineValidationTestEnableDisableTestRequest) GetTestId() string { @@ -40831,7 +40922,7 @@ type MachineValidationTestEnableDisableTestResponse struct { func (x *MachineValidationTestEnableDisableTestResponse) Reset() { *x = MachineValidationTestEnableDisableTestResponse{} - mi := &file_nico_nico_proto_msgTypes[538] + mi := &file_nico_nico_proto_msgTypes[540] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40843,7 +40934,7 @@ func (x *MachineValidationTestEnableDisableTestResponse) String() string { func (*MachineValidationTestEnableDisableTestResponse) ProtoMessage() {} func (x *MachineValidationTestEnableDisableTestResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[538] + mi := &file_nico_nico_proto_msgTypes[540] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40856,7 +40947,7 @@ func (x *MachineValidationTestEnableDisableTestResponse) ProtoReflect() protoref // Deprecated: Use MachineValidationTestEnableDisableTestResponse.ProtoReflect.Descriptor instead. func (*MachineValidationTestEnableDisableTestResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{538} + return file_nico_nico_proto_rawDescGZIP(), []int{540} } func (x *MachineValidationTestEnableDisableTestResponse) GetMessage() string { @@ -40878,7 +40969,7 @@ type MachineValidationRunRequest struct { func (x *MachineValidationRunRequest) Reset() { *x = MachineValidationRunRequest{} - mi := &file_nico_nico_proto_msgTypes[539] + mi := &file_nico_nico_proto_msgTypes[541] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40890,7 +40981,7 @@ func (x *MachineValidationRunRequest) String() string { func (*MachineValidationRunRequest) ProtoMessage() {} func (x *MachineValidationRunRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[539] + mi := &file_nico_nico_proto_msgTypes[541] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40903,7 +40994,7 @@ func (x *MachineValidationRunRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRunRequest.ProtoReflect.Descriptor instead. func (*MachineValidationRunRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{539} + return file_nico_nico_proto_rawDescGZIP(), []int{541} } func (x *MachineValidationRunRequest) GetValidationId() *MachineValidationId { @@ -40943,7 +41034,7 @@ type MachineValidationRunResponse struct { func (x *MachineValidationRunResponse) Reset() { *x = MachineValidationRunResponse{} - mi := &file_nico_nico_proto_msgTypes[540] + mi := &file_nico_nico_proto_msgTypes[542] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -40955,7 +41046,7 @@ func (x *MachineValidationRunResponse) String() string { func (*MachineValidationRunResponse) ProtoMessage() {} func (x *MachineValidationRunResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[540] + mi := &file_nico_nico_proto_msgTypes[542] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -40968,7 +41059,7 @@ func (x *MachineValidationRunResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineValidationRunResponse.ProtoReflect.Descriptor instead. func (*MachineValidationRunResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{540} + return file_nico_nico_proto_rawDescGZIP(), []int{542} } func (x *MachineValidationRunResponse) GetMessage() string { @@ -40991,7 +41082,7 @@ type MachineCapabilityAttributesCpu struct { func (x *MachineCapabilityAttributesCpu) Reset() { *x = MachineCapabilityAttributesCpu{} - mi := &file_nico_nico_proto_msgTypes[541] + mi := &file_nico_nico_proto_msgTypes[543] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41003,7 +41094,7 @@ func (x *MachineCapabilityAttributesCpu) String() string { func (*MachineCapabilityAttributesCpu) ProtoMessage() {} func (x *MachineCapabilityAttributesCpu) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[541] + mi := &file_nico_nico_proto_msgTypes[543] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41016,7 +41107,7 @@ func (x *MachineCapabilityAttributesCpu) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineCapabilityAttributesCpu.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesCpu) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{541} + return file_nico_nico_proto_rawDescGZIP(), []int{543} } func (x *MachineCapabilityAttributesCpu) GetName() string { @@ -41070,7 +41161,7 @@ type MachineCapabilityAttributesGpu struct { func (x *MachineCapabilityAttributesGpu) Reset() { *x = MachineCapabilityAttributesGpu{} - mi := &file_nico_nico_proto_msgTypes[542] + mi := &file_nico_nico_proto_msgTypes[544] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41082,7 +41173,7 @@ func (x *MachineCapabilityAttributesGpu) String() string { func (*MachineCapabilityAttributesGpu) ProtoMessage() {} func (x *MachineCapabilityAttributesGpu) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[542] + mi := &file_nico_nico_proto_msgTypes[544] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41095,7 +41186,7 @@ func (x *MachineCapabilityAttributesGpu) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineCapabilityAttributesGpu.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesGpu) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{542} + return file_nico_nico_proto_rawDescGZIP(), []int{544} } func (x *MachineCapabilityAttributesGpu) GetName() string { @@ -41166,7 +41257,7 @@ type MachineCapabilityAttributesMemory struct { func (x *MachineCapabilityAttributesMemory) Reset() { *x = MachineCapabilityAttributesMemory{} - mi := &file_nico_nico_proto_msgTypes[543] + mi := &file_nico_nico_proto_msgTypes[545] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41178,7 +41269,7 @@ func (x *MachineCapabilityAttributesMemory) String() string { func (*MachineCapabilityAttributesMemory) ProtoMessage() {} func (x *MachineCapabilityAttributesMemory) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[543] + mi := &file_nico_nico_proto_msgTypes[545] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41191,7 +41282,7 @@ func (x *MachineCapabilityAttributesMemory) ProtoReflect() protoreflect.Message // Deprecated: Use MachineCapabilityAttributesMemory.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesMemory) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{543} + return file_nico_nico_proto_rawDescGZIP(), []int{545} } func (x *MachineCapabilityAttributesMemory) GetName() string { @@ -41234,7 +41325,7 @@ type MachineCapabilityAttributesStorage struct { func (x *MachineCapabilityAttributesStorage) Reset() { *x = MachineCapabilityAttributesStorage{} - mi := &file_nico_nico_proto_msgTypes[544] + mi := &file_nico_nico_proto_msgTypes[546] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41246,7 +41337,7 @@ func (x *MachineCapabilityAttributesStorage) String() string { func (*MachineCapabilityAttributesStorage) ProtoMessage() {} func (x *MachineCapabilityAttributesStorage) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[544] + mi := &file_nico_nico_proto_msgTypes[546] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41259,7 +41350,7 @@ func (x *MachineCapabilityAttributesStorage) ProtoReflect() protoreflect.Message // Deprecated: Use MachineCapabilityAttributesStorage.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesStorage) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{544} + return file_nico_nico_proto_rawDescGZIP(), []int{546} } func (x *MachineCapabilityAttributesStorage) GetName() string { @@ -41302,7 +41393,7 @@ type MachineCapabilityAttributesNetwork struct { func (x *MachineCapabilityAttributesNetwork) Reset() { *x = MachineCapabilityAttributesNetwork{} - mi := &file_nico_nico_proto_msgTypes[545] + mi := &file_nico_nico_proto_msgTypes[547] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41314,7 +41405,7 @@ func (x *MachineCapabilityAttributesNetwork) String() string { func (*MachineCapabilityAttributesNetwork) ProtoMessage() {} func (x *MachineCapabilityAttributesNetwork) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[545] + mi := &file_nico_nico_proto_msgTypes[547] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41327,7 +41418,7 @@ func (x *MachineCapabilityAttributesNetwork) ProtoReflect() protoreflect.Message // Deprecated: Use MachineCapabilityAttributesNetwork.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesNetwork) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{545} + return file_nico_nico_proto_rawDescGZIP(), []int{547} } func (x *MachineCapabilityAttributesNetwork) GetName() string { @@ -41377,7 +41468,7 @@ type MachineCapabilityAttributesInfiniband struct { func (x *MachineCapabilityAttributesInfiniband) Reset() { *x = MachineCapabilityAttributesInfiniband{} - mi := &file_nico_nico_proto_msgTypes[546] + mi := &file_nico_nico_proto_msgTypes[548] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41389,7 +41480,7 @@ func (x *MachineCapabilityAttributesInfiniband) String() string { func (*MachineCapabilityAttributesInfiniband) ProtoMessage() {} func (x *MachineCapabilityAttributesInfiniband) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[546] + mi := &file_nico_nico_proto_msgTypes[548] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41402,7 +41493,7 @@ func (x *MachineCapabilityAttributesInfiniband) ProtoReflect() protoreflect.Mess // Deprecated: Use MachineCapabilityAttributesInfiniband.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesInfiniband) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{546} + return file_nico_nico_proto_rawDescGZIP(), []int{548} } func (x *MachineCapabilityAttributesInfiniband) GetName() string { @@ -41444,7 +41535,7 @@ type MachineCapabilityAttributesDpu struct { func (x *MachineCapabilityAttributesDpu) Reset() { *x = MachineCapabilityAttributesDpu{} - mi := &file_nico_nico_proto_msgTypes[547] + mi := &file_nico_nico_proto_msgTypes[549] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41456,7 +41547,7 @@ func (x *MachineCapabilityAttributesDpu) String() string { func (*MachineCapabilityAttributesDpu) ProtoMessage() {} func (x *MachineCapabilityAttributesDpu) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[547] + mi := &file_nico_nico_proto_msgTypes[549] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41469,7 +41560,7 @@ func (x *MachineCapabilityAttributesDpu) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineCapabilityAttributesDpu.ProtoReflect.Descriptor instead. func (*MachineCapabilityAttributesDpu) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{547} + return file_nico_nico_proto_rawDescGZIP(), []int{549} } func (x *MachineCapabilityAttributesDpu) GetName() string { @@ -41508,7 +41599,7 @@ type MachineCapabilitiesSet struct { func (x *MachineCapabilitiesSet) Reset() { *x = MachineCapabilitiesSet{} - mi := &file_nico_nico_proto_msgTypes[548] + mi := &file_nico_nico_proto_msgTypes[550] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41520,7 +41611,7 @@ func (x *MachineCapabilitiesSet) String() string { func (*MachineCapabilitiesSet) ProtoMessage() {} func (x *MachineCapabilitiesSet) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[548] + mi := &file_nico_nico_proto_msgTypes[550] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41533,7 +41624,7 @@ func (x *MachineCapabilitiesSet) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineCapabilitiesSet.ProtoReflect.Descriptor instead. func (*MachineCapabilitiesSet) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{548} + return file_nico_nico_proto_rawDescGZIP(), []int{550} } func (x *MachineCapabilitiesSet) GetCpu() []*MachineCapabilityAttributesCpu { @@ -41597,7 +41688,7 @@ type InstanceTypeAttributes struct { func (x *InstanceTypeAttributes) Reset() { *x = InstanceTypeAttributes{} - mi := &file_nico_nico_proto_msgTypes[549] + mi := &file_nico_nico_proto_msgTypes[551] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41609,7 +41700,7 @@ func (x *InstanceTypeAttributes) String() string { func (*InstanceTypeAttributes) ProtoMessage() {} func (x *InstanceTypeAttributes) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[549] + mi := &file_nico_nico_proto_msgTypes[551] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41622,7 +41713,7 @@ func (x *InstanceTypeAttributes) ProtoReflect() protoreflect.Message { // Deprecated: Use InstanceTypeAttributes.ProtoReflect.Descriptor instead. func (*InstanceTypeAttributes) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{549} + return file_nico_nico_proto_rawDescGZIP(), []int{551} } func (x *InstanceTypeAttributes) GetDesiredCapabilities() []*InstanceTypeMachineCapabilityFilterAttributes { @@ -41651,7 +41742,7 @@ type InstanceType struct { func (x *InstanceType) Reset() { *x = InstanceType{} - mi := &file_nico_nico_proto_msgTypes[550] + mi := &file_nico_nico_proto_msgTypes[552] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41663,7 +41754,7 @@ func (x *InstanceType) String() string { func (*InstanceType) ProtoMessage() {} func (x *InstanceType) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[550] + mi := &file_nico_nico_proto_msgTypes[552] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41676,7 +41767,7 @@ func (x *InstanceType) ProtoReflect() protoreflect.Message { // Deprecated: Use InstanceType.ProtoReflect.Descriptor instead. func (*InstanceType) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{550} + return file_nico_nico_proto_rawDescGZIP(), []int{552} } func (x *InstanceType) GetId() string { @@ -41747,7 +41838,7 @@ type InstanceTypeMachineCapabilityFilterAttributes struct { func (x *InstanceTypeMachineCapabilityFilterAttributes) Reset() { *x = InstanceTypeMachineCapabilityFilterAttributes{} - mi := &file_nico_nico_proto_msgTypes[551] + mi := &file_nico_nico_proto_msgTypes[553] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41759,7 +41850,7 @@ func (x *InstanceTypeMachineCapabilityFilterAttributes) String() string { func (*InstanceTypeMachineCapabilityFilterAttributes) ProtoMessage() {} func (x *InstanceTypeMachineCapabilityFilterAttributes) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[551] + mi := &file_nico_nico_proto_msgTypes[553] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41772,7 +41863,7 @@ func (x *InstanceTypeMachineCapabilityFilterAttributes) ProtoReflect() protorefl // Deprecated: Use InstanceTypeMachineCapabilityFilterAttributes.ProtoReflect.Descriptor instead. func (*InstanceTypeMachineCapabilityFilterAttributes) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{551} + return file_nico_nico_proto_rawDescGZIP(), []int{553} } func (x *InstanceTypeMachineCapabilityFilterAttributes) GetCapabilityType() MachineCapabilityType { @@ -41863,7 +41954,7 @@ type CreateInstanceTypeRequest struct { func (x *CreateInstanceTypeRequest) Reset() { *x = CreateInstanceTypeRequest{} - mi := &file_nico_nico_proto_msgTypes[552] + mi := &file_nico_nico_proto_msgTypes[554] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41875,7 +41966,7 @@ func (x *CreateInstanceTypeRequest) String() string { func (*CreateInstanceTypeRequest) ProtoMessage() {} func (x *CreateInstanceTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[552] + mi := &file_nico_nico_proto_msgTypes[554] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41888,7 +41979,7 @@ func (x *CreateInstanceTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateInstanceTypeRequest.ProtoReflect.Descriptor instead. func (*CreateInstanceTypeRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{552} + return file_nico_nico_proto_rawDescGZIP(), []int{554} } func (x *CreateInstanceTypeRequest) GetId() string { @@ -41921,7 +42012,7 @@ type CreateInstanceTypeResponse struct { func (x *CreateInstanceTypeResponse) Reset() { *x = CreateInstanceTypeResponse{} - mi := &file_nico_nico_proto_msgTypes[553] + mi := &file_nico_nico_proto_msgTypes[555] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41933,7 +42024,7 @@ func (x *CreateInstanceTypeResponse) String() string { func (*CreateInstanceTypeResponse) ProtoMessage() {} func (x *CreateInstanceTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[553] + mi := &file_nico_nico_proto_msgTypes[555] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41946,7 +42037,7 @@ func (x *CreateInstanceTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateInstanceTypeResponse.ProtoReflect.Descriptor instead. func (*CreateInstanceTypeResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{553} + return file_nico_nico_proto_rawDescGZIP(), []int{555} } func (x *CreateInstanceTypeResponse) GetInstanceType() *InstanceType { @@ -41964,7 +42055,7 @@ type FindInstanceTypeIdsRequest struct { func (x *FindInstanceTypeIdsRequest) Reset() { *x = FindInstanceTypeIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[554] + mi := &file_nico_nico_proto_msgTypes[556] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -41976,7 +42067,7 @@ func (x *FindInstanceTypeIdsRequest) String() string { func (*FindInstanceTypeIdsRequest) ProtoMessage() {} func (x *FindInstanceTypeIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[554] + mi := &file_nico_nico_proto_msgTypes[556] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -41989,7 +42080,7 @@ func (x *FindInstanceTypeIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FindInstanceTypeIdsRequest.ProtoReflect.Descriptor instead. func (*FindInstanceTypeIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{554} + return file_nico_nico_proto_rawDescGZIP(), []int{556} } type FindInstanceTypeIdsResponse struct { @@ -42001,7 +42092,7 @@ type FindInstanceTypeIdsResponse struct { func (x *FindInstanceTypeIdsResponse) Reset() { *x = FindInstanceTypeIdsResponse{} - mi := &file_nico_nico_proto_msgTypes[555] + mi := &file_nico_nico_proto_msgTypes[557] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42013,7 +42104,7 @@ func (x *FindInstanceTypeIdsResponse) String() string { func (*FindInstanceTypeIdsResponse) ProtoMessage() {} func (x *FindInstanceTypeIdsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[555] + mi := &file_nico_nico_proto_msgTypes[557] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42026,7 +42117,7 @@ func (x *FindInstanceTypeIdsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FindInstanceTypeIdsResponse.ProtoReflect.Descriptor instead. func (*FindInstanceTypeIdsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{555} + return file_nico_nico_proto_rawDescGZIP(), []int{557} } func (x *FindInstanceTypeIdsResponse) GetInstanceTypeIds() []string { @@ -42049,7 +42140,7 @@ type FindInstanceTypesByIdsRequest struct { func (x *FindInstanceTypesByIdsRequest) Reset() { *x = FindInstanceTypesByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[556] + mi := &file_nico_nico_proto_msgTypes[558] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42061,7 +42152,7 @@ func (x *FindInstanceTypesByIdsRequest) String() string { func (*FindInstanceTypesByIdsRequest) ProtoMessage() {} func (x *FindInstanceTypesByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[556] + mi := &file_nico_nico_proto_msgTypes[558] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42074,7 +42165,7 @@ func (x *FindInstanceTypesByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FindInstanceTypesByIdsRequest.ProtoReflect.Descriptor instead. func (*FindInstanceTypesByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{556} + return file_nico_nico_proto_rawDescGZIP(), []int{558} } func (x *FindInstanceTypesByIdsRequest) GetInstanceTypeIds() []string { @@ -42107,7 +42198,7 @@ type FindInstanceTypesByIdsResponse struct { func (x *FindInstanceTypesByIdsResponse) Reset() { *x = FindInstanceTypesByIdsResponse{} - mi := &file_nico_nico_proto_msgTypes[557] + mi := &file_nico_nico_proto_msgTypes[559] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42119,7 +42210,7 @@ func (x *FindInstanceTypesByIdsResponse) String() string { func (*FindInstanceTypesByIdsResponse) ProtoMessage() {} func (x *FindInstanceTypesByIdsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[557] + mi := &file_nico_nico_proto_msgTypes[559] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42132,7 +42223,7 @@ func (x *FindInstanceTypesByIdsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FindInstanceTypesByIdsResponse.ProtoReflect.Descriptor instead. func (*FindInstanceTypesByIdsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{557} + return file_nico_nico_proto_rawDescGZIP(), []int{559} } func (x *FindInstanceTypesByIdsResponse) GetInstanceTypes() []*InstanceType { @@ -42151,7 +42242,7 @@ type DeleteInstanceTypeRequest struct { func (x *DeleteInstanceTypeRequest) Reset() { *x = DeleteInstanceTypeRequest{} - mi := &file_nico_nico_proto_msgTypes[558] + mi := &file_nico_nico_proto_msgTypes[560] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42163,7 +42254,7 @@ func (x *DeleteInstanceTypeRequest) String() string { func (*DeleteInstanceTypeRequest) ProtoMessage() {} func (x *DeleteInstanceTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[558] + mi := &file_nico_nico_proto_msgTypes[560] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42176,7 +42267,7 @@ func (x *DeleteInstanceTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteInstanceTypeRequest.ProtoReflect.Descriptor instead. func (*DeleteInstanceTypeRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{558} + return file_nico_nico_proto_rawDescGZIP(), []int{560} } func (x *DeleteInstanceTypeRequest) GetId() string { @@ -42194,7 +42285,7 @@ type DeleteInstanceTypeResponse struct { func (x *DeleteInstanceTypeResponse) Reset() { *x = DeleteInstanceTypeResponse{} - mi := &file_nico_nico_proto_msgTypes[559] + mi := &file_nico_nico_proto_msgTypes[561] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42206,7 +42297,7 @@ func (x *DeleteInstanceTypeResponse) String() string { func (*DeleteInstanceTypeResponse) ProtoMessage() {} func (x *DeleteInstanceTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[559] + mi := &file_nico_nico_proto_msgTypes[561] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42219,7 +42310,7 @@ func (x *DeleteInstanceTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteInstanceTypeResponse.ProtoReflect.Descriptor instead. func (*DeleteInstanceTypeResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{559} + return file_nico_nico_proto_rawDescGZIP(), []int{561} } type UpdateInstanceTypeResponse struct { @@ -42231,7 +42322,7 @@ type UpdateInstanceTypeResponse struct { func (x *UpdateInstanceTypeResponse) Reset() { *x = UpdateInstanceTypeResponse{} - mi := &file_nico_nico_proto_msgTypes[560] + mi := &file_nico_nico_proto_msgTypes[562] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42243,7 +42334,7 @@ func (x *UpdateInstanceTypeResponse) String() string { func (*UpdateInstanceTypeResponse) ProtoMessage() {} func (x *UpdateInstanceTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[560] + mi := &file_nico_nico_proto_msgTypes[562] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42256,7 +42347,7 @@ func (x *UpdateInstanceTypeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateInstanceTypeResponse.ProtoReflect.Descriptor instead. func (*UpdateInstanceTypeResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{560} + return file_nico_nico_proto_rawDescGZIP(), []int{562} } func (x *UpdateInstanceTypeResponse) GetInstanceType() *InstanceType { @@ -42278,7 +42369,7 @@ type UpdateInstanceTypeRequest struct { func (x *UpdateInstanceTypeRequest) Reset() { *x = UpdateInstanceTypeRequest{} - mi := &file_nico_nico_proto_msgTypes[561] + mi := &file_nico_nico_proto_msgTypes[563] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42290,7 +42381,7 @@ func (x *UpdateInstanceTypeRequest) String() string { func (*UpdateInstanceTypeRequest) ProtoMessage() {} func (x *UpdateInstanceTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[561] + mi := &file_nico_nico_proto_msgTypes[563] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42303,7 +42394,7 @@ func (x *UpdateInstanceTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateInstanceTypeRequest.ProtoReflect.Descriptor instead. func (*UpdateInstanceTypeRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{561} + return file_nico_nico_proto_rawDescGZIP(), []int{563} } func (x *UpdateInstanceTypeRequest) GetId() string { @@ -42344,7 +42435,7 @@ type AssociateMachinesWithInstanceTypeRequest struct { func (x *AssociateMachinesWithInstanceTypeRequest) Reset() { *x = AssociateMachinesWithInstanceTypeRequest{} - mi := &file_nico_nico_proto_msgTypes[562] + mi := &file_nico_nico_proto_msgTypes[564] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42356,7 +42447,7 @@ func (x *AssociateMachinesWithInstanceTypeRequest) String() string { func (*AssociateMachinesWithInstanceTypeRequest) ProtoMessage() {} func (x *AssociateMachinesWithInstanceTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[562] + mi := &file_nico_nico_proto_msgTypes[564] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42369,7 +42460,7 @@ func (x *AssociateMachinesWithInstanceTypeRequest) ProtoReflect() protoreflect.M // Deprecated: Use AssociateMachinesWithInstanceTypeRequest.ProtoReflect.Descriptor instead. func (*AssociateMachinesWithInstanceTypeRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{562} + return file_nico_nico_proto_rawDescGZIP(), []int{564} } func (x *AssociateMachinesWithInstanceTypeRequest) GetInstanceTypeId() string { @@ -42394,7 +42485,7 @@ type AssociateMachinesWithInstanceTypeResponse struct { func (x *AssociateMachinesWithInstanceTypeResponse) Reset() { *x = AssociateMachinesWithInstanceTypeResponse{} - mi := &file_nico_nico_proto_msgTypes[563] + mi := &file_nico_nico_proto_msgTypes[565] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42406,7 +42497,7 @@ func (x *AssociateMachinesWithInstanceTypeResponse) String() string { func (*AssociateMachinesWithInstanceTypeResponse) ProtoMessage() {} func (x *AssociateMachinesWithInstanceTypeResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[563] + mi := &file_nico_nico_proto_msgTypes[565] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42419,7 +42510,7 @@ func (x *AssociateMachinesWithInstanceTypeResponse) ProtoReflect() protoreflect. // Deprecated: Use AssociateMachinesWithInstanceTypeResponse.ProtoReflect.Descriptor instead. func (*AssociateMachinesWithInstanceTypeResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{563} + return file_nico_nico_proto_rawDescGZIP(), []int{565} } type RemoveMachineInstanceTypeAssociationRequest struct { @@ -42431,7 +42522,7 @@ type RemoveMachineInstanceTypeAssociationRequest struct { func (x *RemoveMachineInstanceTypeAssociationRequest) Reset() { *x = RemoveMachineInstanceTypeAssociationRequest{} - mi := &file_nico_nico_proto_msgTypes[564] + mi := &file_nico_nico_proto_msgTypes[566] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42443,7 +42534,7 @@ func (x *RemoveMachineInstanceTypeAssociationRequest) String() string { func (*RemoveMachineInstanceTypeAssociationRequest) ProtoMessage() {} func (x *RemoveMachineInstanceTypeAssociationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[564] + mi := &file_nico_nico_proto_msgTypes[566] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42456,7 +42547,7 @@ func (x *RemoveMachineInstanceTypeAssociationRequest) ProtoReflect() protoreflec // Deprecated: Use RemoveMachineInstanceTypeAssociationRequest.ProtoReflect.Descriptor instead. func (*RemoveMachineInstanceTypeAssociationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{564} + return file_nico_nico_proto_rawDescGZIP(), []int{566} } func (x *RemoveMachineInstanceTypeAssociationRequest) GetMachineId() string { @@ -42474,7 +42565,7 @@ type RemoveMachineInstanceTypeAssociationResponse struct { func (x *RemoveMachineInstanceTypeAssociationResponse) Reset() { *x = RemoveMachineInstanceTypeAssociationResponse{} - mi := &file_nico_nico_proto_msgTypes[565] + mi := &file_nico_nico_proto_msgTypes[567] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42486,7 +42577,7 @@ func (x *RemoveMachineInstanceTypeAssociationResponse) String() string { func (*RemoveMachineInstanceTypeAssociationResponse) ProtoMessage() {} func (x *RemoveMachineInstanceTypeAssociationResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[565] + mi := &file_nico_nico_proto_msgTypes[567] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42499,7 +42590,7 @@ func (x *RemoveMachineInstanceTypeAssociationResponse) ProtoReflect() protorefle // Deprecated: Use RemoveMachineInstanceTypeAssociationResponse.ProtoReflect.Descriptor instead. func (*RemoveMachineInstanceTypeAssociationResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{565} + return file_nico_nico_proto_rawDescGZIP(), []int{567} } type RedfishBrowseRequest struct { @@ -42511,7 +42602,7 @@ type RedfishBrowseRequest struct { func (x *RedfishBrowseRequest) Reset() { *x = RedfishBrowseRequest{} - mi := &file_nico_nico_proto_msgTypes[566] + mi := &file_nico_nico_proto_msgTypes[568] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42523,7 +42614,7 @@ func (x *RedfishBrowseRequest) String() string { func (*RedfishBrowseRequest) ProtoMessage() {} func (x *RedfishBrowseRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[566] + mi := &file_nico_nico_proto_msgTypes[568] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42536,7 +42627,7 @@ func (x *RedfishBrowseRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishBrowseRequest.ProtoReflect.Descriptor instead. func (*RedfishBrowseRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{566} + return file_nico_nico_proto_rawDescGZIP(), []int{568} } func (x *RedfishBrowseRequest) GetUri() string { @@ -42557,7 +42648,7 @@ type RedfishBrowseResponse struct { func (x *RedfishBrowseResponse) Reset() { *x = RedfishBrowseResponse{} - mi := &file_nico_nico_proto_msgTypes[567] + mi := &file_nico_nico_proto_msgTypes[569] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42569,7 +42660,7 @@ func (x *RedfishBrowseResponse) String() string { func (*RedfishBrowseResponse) ProtoMessage() {} func (x *RedfishBrowseResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[567] + mi := &file_nico_nico_proto_msgTypes[569] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42582,7 +42673,7 @@ func (x *RedfishBrowseResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishBrowseResponse.ProtoReflect.Descriptor instead. func (*RedfishBrowseResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{567} + return file_nico_nico_proto_rawDescGZIP(), []int{569} } func (x *RedfishBrowseResponse) GetText() string { @@ -42608,7 +42699,7 @@ type RedfishListActionsRequest struct { func (x *RedfishListActionsRequest) Reset() { *x = RedfishListActionsRequest{} - mi := &file_nico_nico_proto_msgTypes[568] + mi := &file_nico_nico_proto_msgTypes[570] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42620,7 +42711,7 @@ func (x *RedfishListActionsRequest) String() string { func (*RedfishListActionsRequest) ProtoMessage() {} func (x *RedfishListActionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[568] + mi := &file_nico_nico_proto_msgTypes[570] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42633,7 +42724,7 @@ func (x *RedfishListActionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishListActionsRequest.ProtoReflect.Descriptor instead. func (*RedfishListActionsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{568} + return file_nico_nico_proto_rawDescGZIP(), []int{570} } func (x *RedfishListActionsRequest) GetMachineIp() string { @@ -42652,7 +42743,7 @@ type RedfishListActionsResponse struct { func (x *RedfishListActionsResponse) Reset() { *x = RedfishListActionsResponse{} - mi := &file_nico_nico_proto_msgTypes[569] + mi := &file_nico_nico_proto_msgTypes[571] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42664,7 +42755,7 @@ func (x *RedfishListActionsResponse) String() string { func (*RedfishListActionsResponse) ProtoMessage() {} func (x *RedfishListActionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[569] + mi := &file_nico_nico_proto_msgTypes[571] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42677,7 +42768,7 @@ func (x *RedfishListActionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishListActionsResponse.ProtoReflect.Descriptor instead. func (*RedfishListActionsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{569} + return file_nico_nico_proto_rawDescGZIP(), []int{571} } func (x *RedfishListActionsResponse) GetActions() []*RedfishAction { @@ -42710,7 +42801,7 @@ type RedfishAction struct { func (x *RedfishAction) Reset() { *x = RedfishAction{} - mi := &file_nico_nico_proto_msgTypes[570] + mi := &file_nico_nico_proto_msgTypes[572] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42722,7 +42813,7 @@ func (x *RedfishAction) String() string { func (*RedfishAction) ProtoMessage() {} func (x *RedfishAction) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[570] + mi := &file_nico_nico_proto_msgTypes[572] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42735,7 +42826,7 @@ func (x *RedfishAction) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishAction.ProtoReflect.Descriptor instead. func (*RedfishAction) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{570} + return file_nico_nico_proto_rawDescGZIP(), []int{572} } func (x *RedfishAction) GetRequestId() int64 { @@ -42831,7 +42922,7 @@ type OptionalRedfishActionResult struct { func (x *OptionalRedfishActionResult) Reset() { *x = OptionalRedfishActionResult{} - mi := &file_nico_nico_proto_msgTypes[571] + mi := &file_nico_nico_proto_msgTypes[573] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42843,7 +42934,7 @@ func (x *OptionalRedfishActionResult) String() string { func (*OptionalRedfishActionResult) ProtoMessage() {} func (x *OptionalRedfishActionResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[571] + mi := &file_nico_nico_proto_msgTypes[573] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42856,7 +42947,7 @@ func (x *OptionalRedfishActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use OptionalRedfishActionResult.ProtoReflect.Descriptor instead. func (*OptionalRedfishActionResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{571} + return file_nico_nico_proto_rawDescGZIP(), []int{573} } func (x *OptionalRedfishActionResult) GetResult() *RedfishActionResult { @@ -42878,7 +42969,7 @@ type RedfishActionResult struct { func (x *RedfishActionResult) Reset() { *x = RedfishActionResult{} - mi := &file_nico_nico_proto_msgTypes[572] + mi := &file_nico_nico_proto_msgTypes[574] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42890,7 +42981,7 @@ func (x *RedfishActionResult) String() string { func (*RedfishActionResult) ProtoMessage() {} func (x *RedfishActionResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[572] + mi := &file_nico_nico_proto_msgTypes[574] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42903,7 +42994,7 @@ func (x *RedfishActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishActionResult.ProtoReflect.Descriptor instead. func (*RedfishActionResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{572} + return file_nico_nico_proto_rawDescGZIP(), []int{574} } func (x *RedfishActionResult) GetHeaders() map[string]string { @@ -42946,7 +43037,7 @@ type RedfishCreateActionRequest struct { func (x *RedfishCreateActionRequest) Reset() { *x = RedfishCreateActionRequest{} - mi := &file_nico_nico_proto_msgTypes[573] + mi := &file_nico_nico_proto_msgTypes[575] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -42958,7 +43049,7 @@ func (x *RedfishCreateActionRequest) String() string { func (*RedfishCreateActionRequest) ProtoMessage() {} func (x *RedfishCreateActionRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[573] + mi := &file_nico_nico_proto_msgTypes[575] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -42971,7 +43062,7 @@ func (x *RedfishCreateActionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishCreateActionRequest.ProtoReflect.Descriptor instead. func (*RedfishCreateActionRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{573} + return file_nico_nico_proto_rawDescGZIP(), []int{575} } func (x *RedfishCreateActionRequest) GetIps() []string { @@ -43011,7 +43102,7 @@ type RedfishCreateActionResponse struct { func (x *RedfishCreateActionResponse) Reset() { *x = RedfishCreateActionResponse{} - mi := &file_nico_nico_proto_msgTypes[574] + mi := &file_nico_nico_proto_msgTypes[576] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43023,7 +43114,7 @@ func (x *RedfishCreateActionResponse) String() string { func (*RedfishCreateActionResponse) ProtoMessage() {} func (x *RedfishCreateActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[574] + mi := &file_nico_nico_proto_msgTypes[576] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43036,7 +43127,7 @@ func (x *RedfishCreateActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishCreateActionResponse.ProtoReflect.Descriptor instead. func (*RedfishCreateActionResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{574} + return file_nico_nico_proto_rawDescGZIP(), []int{576} } func (x *RedfishCreateActionResponse) GetRequestId() int64 { @@ -43055,7 +43146,7 @@ type RedfishActionID struct { func (x *RedfishActionID) Reset() { *x = RedfishActionID{} - mi := &file_nico_nico_proto_msgTypes[575] + mi := &file_nico_nico_proto_msgTypes[577] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43067,7 +43158,7 @@ func (x *RedfishActionID) String() string { func (*RedfishActionID) ProtoMessage() {} func (x *RedfishActionID) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[575] + mi := &file_nico_nico_proto_msgTypes[577] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43080,7 +43171,7 @@ func (x *RedfishActionID) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishActionID.ProtoReflect.Descriptor instead. func (*RedfishActionID) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{575} + return file_nico_nico_proto_rawDescGZIP(), []int{577} } func (x *RedfishActionID) GetRequestId() int64 { @@ -43098,7 +43189,7 @@ type RedfishApproveActionResponse struct { func (x *RedfishApproveActionResponse) Reset() { *x = RedfishApproveActionResponse{} - mi := &file_nico_nico_proto_msgTypes[576] + mi := &file_nico_nico_proto_msgTypes[578] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43110,7 +43201,7 @@ func (x *RedfishApproveActionResponse) String() string { func (*RedfishApproveActionResponse) ProtoMessage() {} func (x *RedfishApproveActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[576] + mi := &file_nico_nico_proto_msgTypes[578] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43123,7 +43214,7 @@ func (x *RedfishApproveActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishApproveActionResponse.ProtoReflect.Descriptor instead. func (*RedfishApproveActionResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{576} + return file_nico_nico_proto_rawDescGZIP(), []int{578} } type RedfishApplyActionResponse struct { @@ -43134,7 +43225,7 @@ type RedfishApplyActionResponse struct { func (x *RedfishApplyActionResponse) Reset() { *x = RedfishApplyActionResponse{} - mi := &file_nico_nico_proto_msgTypes[577] + mi := &file_nico_nico_proto_msgTypes[579] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43146,7 +43237,7 @@ func (x *RedfishApplyActionResponse) String() string { func (*RedfishApplyActionResponse) ProtoMessage() {} func (x *RedfishApplyActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[577] + mi := &file_nico_nico_proto_msgTypes[579] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43159,7 +43250,7 @@ func (x *RedfishApplyActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishApplyActionResponse.ProtoReflect.Descriptor instead. func (*RedfishApplyActionResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{577} + return file_nico_nico_proto_rawDescGZIP(), []int{579} } type RedfishCancelActionResponse struct { @@ -43170,7 +43261,7 @@ type RedfishCancelActionResponse struct { func (x *RedfishCancelActionResponse) Reset() { *x = RedfishCancelActionResponse{} - mi := &file_nico_nico_proto_msgTypes[578] + mi := &file_nico_nico_proto_msgTypes[580] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43182,7 +43273,7 @@ func (x *RedfishCancelActionResponse) String() string { func (*RedfishCancelActionResponse) ProtoMessage() {} func (x *RedfishCancelActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[578] + mi := &file_nico_nico_proto_msgTypes[580] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43195,7 +43286,7 @@ func (x *RedfishCancelActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RedfishCancelActionResponse.ProtoReflect.Descriptor instead. func (*RedfishCancelActionResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{578} + return file_nico_nico_proto_rawDescGZIP(), []int{580} } type UfmBrowseRequest struct { @@ -43210,7 +43301,7 @@ type UfmBrowseRequest struct { func (x *UfmBrowseRequest) Reset() { *x = UfmBrowseRequest{} - mi := &file_nico_nico_proto_msgTypes[579] + mi := &file_nico_nico_proto_msgTypes[581] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43222,7 +43313,7 @@ func (x *UfmBrowseRequest) String() string { func (*UfmBrowseRequest) ProtoMessage() {} func (x *UfmBrowseRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[579] + mi := &file_nico_nico_proto_msgTypes[581] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43235,7 +43326,7 @@ func (x *UfmBrowseRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UfmBrowseRequest.ProtoReflect.Descriptor instead. func (*UfmBrowseRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{579} + return file_nico_nico_proto_rawDescGZIP(), []int{581} } func (x *UfmBrowseRequest) GetFabricId() string { @@ -43266,7 +43357,7 @@ type UfmBrowseResponse struct { func (x *UfmBrowseResponse) Reset() { *x = UfmBrowseResponse{} - mi := &file_nico_nico_proto_msgTypes[580] + mi := &file_nico_nico_proto_msgTypes[582] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43278,7 +43369,7 @@ func (x *UfmBrowseResponse) String() string { func (*UfmBrowseResponse) ProtoMessage() {} func (x *UfmBrowseResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[580] + mi := &file_nico_nico_proto_msgTypes[582] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43291,7 +43382,7 @@ func (x *UfmBrowseResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UfmBrowseResponse.ProtoReflect.Descriptor instead. func (*UfmBrowseResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{580} + return file_nico_nico_proto_rawDescGZIP(), []int{582} } func (x *UfmBrowseResponse) GetBody() string { @@ -43326,7 +43417,7 @@ type NetworkSecurityGroupAttributes struct { func (x *NetworkSecurityGroupAttributes) Reset() { *x = NetworkSecurityGroupAttributes{} - mi := &file_nico_nico_proto_msgTypes[581] + mi := &file_nico_nico_proto_msgTypes[583] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43338,7 +43429,7 @@ func (x *NetworkSecurityGroupAttributes) String() string { func (*NetworkSecurityGroupAttributes) ProtoMessage() {} func (x *NetworkSecurityGroupAttributes) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[581] + mi := &file_nico_nico_proto_msgTypes[583] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43351,7 +43442,7 @@ func (x *NetworkSecurityGroupAttributes) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkSecurityGroupAttributes.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroupAttributes) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{581} + return file_nico_nico_proto_rawDescGZIP(), []int{583} } func (x *NetworkSecurityGroupAttributes) GetRules() []*NetworkSecurityGroupRuleAttributes { @@ -43384,7 +43475,7 @@ type NetworkSecurityGroup struct { func (x *NetworkSecurityGroup) Reset() { *x = NetworkSecurityGroup{} - mi := &file_nico_nico_proto_msgTypes[582] + mi := &file_nico_nico_proto_msgTypes[584] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43396,7 +43487,7 @@ func (x *NetworkSecurityGroup) String() string { func (*NetworkSecurityGroup) ProtoMessage() {} func (x *NetworkSecurityGroup) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[582] + mi := &file_nico_nico_proto_msgTypes[584] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43409,7 +43500,7 @@ func (x *NetworkSecurityGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkSecurityGroup.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroup) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{582} + return file_nico_nico_proto_rawDescGZIP(), []int{584} } func (x *NetworkSecurityGroup) GetId() string { @@ -43480,7 +43571,7 @@ type CreateNetworkSecurityGroupRequest struct { func (x *CreateNetworkSecurityGroupRequest) Reset() { *x = CreateNetworkSecurityGroupRequest{} - mi := &file_nico_nico_proto_msgTypes[583] + mi := &file_nico_nico_proto_msgTypes[585] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43492,7 +43583,7 @@ func (x *CreateNetworkSecurityGroupRequest) String() string { func (*CreateNetworkSecurityGroupRequest) ProtoMessage() {} func (x *CreateNetworkSecurityGroupRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[583] + mi := &file_nico_nico_proto_msgTypes[585] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43505,7 +43596,7 @@ func (x *CreateNetworkSecurityGroupRequest) ProtoReflect() protoreflect.Message // Deprecated: Use CreateNetworkSecurityGroupRequest.ProtoReflect.Descriptor instead. func (*CreateNetworkSecurityGroupRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{583} + return file_nico_nico_proto_rawDescGZIP(), []int{585} } func (x *CreateNetworkSecurityGroupRequest) GetId() string { @@ -43545,7 +43636,7 @@ type CreateNetworkSecurityGroupResponse struct { func (x *CreateNetworkSecurityGroupResponse) Reset() { *x = CreateNetworkSecurityGroupResponse{} - mi := &file_nico_nico_proto_msgTypes[584] + mi := &file_nico_nico_proto_msgTypes[586] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43557,7 +43648,7 @@ func (x *CreateNetworkSecurityGroupResponse) String() string { func (*CreateNetworkSecurityGroupResponse) ProtoMessage() {} func (x *CreateNetworkSecurityGroupResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[584] + mi := &file_nico_nico_proto_msgTypes[586] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43570,7 +43661,7 @@ func (x *CreateNetworkSecurityGroupResponse) ProtoReflect() protoreflect.Message // Deprecated: Use CreateNetworkSecurityGroupResponse.ProtoReflect.Descriptor instead. func (*CreateNetworkSecurityGroupResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{584} + return file_nico_nico_proto_rawDescGZIP(), []int{586} } func (x *CreateNetworkSecurityGroupResponse) GetNetworkSecurityGroup() *NetworkSecurityGroup { @@ -43590,7 +43681,7 @@ type FindNetworkSecurityGroupIdsRequest struct { func (x *FindNetworkSecurityGroupIdsRequest) Reset() { *x = FindNetworkSecurityGroupIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[585] + mi := &file_nico_nico_proto_msgTypes[587] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43602,7 +43693,7 @@ func (x *FindNetworkSecurityGroupIdsRequest) String() string { func (*FindNetworkSecurityGroupIdsRequest) ProtoMessage() {} func (x *FindNetworkSecurityGroupIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[585] + mi := &file_nico_nico_proto_msgTypes[587] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43615,7 +43706,7 @@ func (x *FindNetworkSecurityGroupIdsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use FindNetworkSecurityGroupIdsRequest.ProtoReflect.Descriptor instead. func (*FindNetworkSecurityGroupIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{585} + return file_nico_nico_proto_rawDescGZIP(), []int{587} } func (x *FindNetworkSecurityGroupIdsRequest) GetName() string { @@ -43641,7 +43732,7 @@ type FindNetworkSecurityGroupIdsResponse struct { func (x *FindNetworkSecurityGroupIdsResponse) Reset() { *x = FindNetworkSecurityGroupIdsResponse{} - mi := &file_nico_nico_proto_msgTypes[586] + mi := &file_nico_nico_proto_msgTypes[588] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43653,7 +43744,7 @@ func (x *FindNetworkSecurityGroupIdsResponse) String() string { func (*FindNetworkSecurityGroupIdsResponse) ProtoMessage() {} func (x *FindNetworkSecurityGroupIdsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[586] + mi := &file_nico_nico_proto_msgTypes[588] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43666,7 +43757,7 @@ func (x *FindNetworkSecurityGroupIdsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use FindNetworkSecurityGroupIdsResponse.ProtoReflect.Descriptor instead. func (*FindNetworkSecurityGroupIdsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{586} + return file_nico_nico_proto_rawDescGZIP(), []int{588} } func (x *FindNetworkSecurityGroupIdsResponse) GetNetworkSecurityGroupIds() []string { @@ -43686,7 +43777,7 @@ type FindNetworkSecurityGroupsByIdsRequest struct { func (x *FindNetworkSecurityGroupsByIdsRequest) Reset() { *x = FindNetworkSecurityGroupsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[587] + mi := &file_nico_nico_proto_msgTypes[589] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43698,7 +43789,7 @@ func (x *FindNetworkSecurityGroupsByIdsRequest) String() string { func (*FindNetworkSecurityGroupsByIdsRequest) ProtoMessage() {} func (x *FindNetworkSecurityGroupsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[587] + mi := &file_nico_nico_proto_msgTypes[589] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43711,7 +43802,7 @@ func (x *FindNetworkSecurityGroupsByIdsRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use FindNetworkSecurityGroupsByIdsRequest.ProtoReflect.Descriptor instead. func (*FindNetworkSecurityGroupsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{587} + return file_nico_nico_proto_rawDescGZIP(), []int{589} } func (x *FindNetworkSecurityGroupsByIdsRequest) GetNetworkSecurityGroupIds() []string { @@ -43737,7 +43828,7 @@ type FindNetworkSecurityGroupsByIdsResponse struct { func (x *FindNetworkSecurityGroupsByIdsResponse) Reset() { *x = FindNetworkSecurityGroupsByIdsResponse{} - mi := &file_nico_nico_proto_msgTypes[588] + mi := &file_nico_nico_proto_msgTypes[590] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43749,7 +43840,7 @@ func (x *FindNetworkSecurityGroupsByIdsResponse) String() string { func (*FindNetworkSecurityGroupsByIdsResponse) ProtoMessage() {} func (x *FindNetworkSecurityGroupsByIdsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[588] + mi := &file_nico_nico_proto_msgTypes[590] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43762,7 +43853,7 @@ func (x *FindNetworkSecurityGroupsByIdsResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use FindNetworkSecurityGroupsByIdsResponse.ProtoReflect.Descriptor instead. func (*FindNetworkSecurityGroupsByIdsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{588} + return file_nico_nico_proto_rawDescGZIP(), []int{590} } func (x *FindNetworkSecurityGroupsByIdsResponse) GetNetworkSecurityGroups() []*NetworkSecurityGroup { @@ -43781,7 +43872,7 @@ type UpdateNetworkSecurityGroupResponse struct { func (x *UpdateNetworkSecurityGroupResponse) Reset() { *x = UpdateNetworkSecurityGroupResponse{} - mi := &file_nico_nico_proto_msgTypes[589] + mi := &file_nico_nico_proto_msgTypes[591] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43793,7 +43884,7 @@ func (x *UpdateNetworkSecurityGroupResponse) String() string { func (*UpdateNetworkSecurityGroupResponse) ProtoMessage() {} func (x *UpdateNetworkSecurityGroupResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[589] + mi := &file_nico_nico_proto_msgTypes[591] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43806,7 +43897,7 @@ func (x *UpdateNetworkSecurityGroupResponse) ProtoReflect() protoreflect.Message // Deprecated: Use UpdateNetworkSecurityGroupResponse.ProtoReflect.Descriptor instead. func (*UpdateNetworkSecurityGroupResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{589} + return file_nico_nico_proto_rawDescGZIP(), []int{591} } func (x *UpdateNetworkSecurityGroupResponse) GetNetworkSecurityGroup() *NetworkSecurityGroup { @@ -43829,7 +43920,7 @@ type UpdateNetworkSecurityGroupRequest struct { func (x *UpdateNetworkSecurityGroupRequest) Reset() { *x = UpdateNetworkSecurityGroupRequest{} - mi := &file_nico_nico_proto_msgTypes[590] + mi := &file_nico_nico_proto_msgTypes[592] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43841,7 +43932,7 @@ func (x *UpdateNetworkSecurityGroupRequest) String() string { func (*UpdateNetworkSecurityGroupRequest) ProtoMessage() {} func (x *UpdateNetworkSecurityGroupRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[590] + mi := &file_nico_nico_proto_msgTypes[592] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43854,7 +43945,7 @@ func (x *UpdateNetworkSecurityGroupRequest) ProtoReflect() protoreflect.Message // Deprecated: Use UpdateNetworkSecurityGroupRequest.ProtoReflect.Descriptor instead. func (*UpdateNetworkSecurityGroupRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{590} + return file_nico_nico_proto_rawDescGZIP(), []int{592} } func (x *UpdateNetworkSecurityGroupRequest) GetId() string { @@ -43902,7 +43993,7 @@ type DeleteNetworkSecurityGroupRequest struct { func (x *DeleteNetworkSecurityGroupRequest) Reset() { *x = DeleteNetworkSecurityGroupRequest{} - mi := &file_nico_nico_proto_msgTypes[591] + mi := &file_nico_nico_proto_msgTypes[593] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43914,7 +44005,7 @@ func (x *DeleteNetworkSecurityGroupRequest) String() string { func (*DeleteNetworkSecurityGroupRequest) ProtoMessage() {} func (x *DeleteNetworkSecurityGroupRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[591] + mi := &file_nico_nico_proto_msgTypes[593] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43927,7 +44018,7 @@ func (x *DeleteNetworkSecurityGroupRequest) ProtoReflect() protoreflect.Message // Deprecated: Use DeleteNetworkSecurityGroupRequest.ProtoReflect.Descriptor instead. func (*DeleteNetworkSecurityGroupRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{591} + return file_nico_nico_proto_rawDescGZIP(), []int{593} } func (x *DeleteNetworkSecurityGroupRequest) GetId() string { @@ -43952,7 +44043,7 @@ type DeleteNetworkSecurityGroupResponse struct { func (x *DeleteNetworkSecurityGroupResponse) Reset() { *x = DeleteNetworkSecurityGroupResponse{} - mi := &file_nico_nico_proto_msgTypes[592] + mi := &file_nico_nico_proto_msgTypes[594] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -43964,7 +44055,7 @@ func (x *DeleteNetworkSecurityGroupResponse) String() string { func (*DeleteNetworkSecurityGroupResponse) ProtoMessage() {} func (x *DeleteNetworkSecurityGroupResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[592] + mi := &file_nico_nico_proto_msgTypes[594] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -43977,7 +44068,7 @@ func (x *DeleteNetworkSecurityGroupResponse) ProtoReflect() protoreflect.Message // Deprecated: Use DeleteNetworkSecurityGroupResponse.ProtoReflect.Descriptor instead. func (*DeleteNetworkSecurityGroupResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{592} + return file_nico_nico_proto_rawDescGZIP(), []int{594} } type NetworkSecurityGroupStatus struct { @@ -43991,7 +44082,7 @@ type NetworkSecurityGroupStatus struct { func (x *NetworkSecurityGroupStatus) Reset() { *x = NetworkSecurityGroupStatus{} - mi := &file_nico_nico_proto_msgTypes[593] + mi := &file_nico_nico_proto_msgTypes[595] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44003,7 +44094,7 @@ func (x *NetworkSecurityGroupStatus) String() string { func (*NetworkSecurityGroupStatus) ProtoMessage() {} func (x *NetworkSecurityGroupStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[593] + mi := &file_nico_nico_proto_msgTypes[595] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44016,7 +44107,7 @@ func (x *NetworkSecurityGroupStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkSecurityGroupStatus.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroupStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{593} + return file_nico_nico_proto_rawDescGZIP(), []int{595} } func (x *NetworkSecurityGroupStatus) GetSource() NetworkSecurityGroupSource { @@ -44069,7 +44160,7 @@ type NetworkSecurityGroupPropagationObjectStatus struct { func (x *NetworkSecurityGroupPropagationObjectStatus) Reset() { *x = NetworkSecurityGroupPropagationObjectStatus{} - mi := &file_nico_nico_proto_msgTypes[594] + mi := &file_nico_nico_proto_msgTypes[596] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44081,7 +44172,7 @@ func (x *NetworkSecurityGroupPropagationObjectStatus) String() string { func (*NetworkSecurityGroupPropagationObjectStatus) ProtoMessage() {} func (x *NetworkSecurityGroupPropagationObjectStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[594] + mi := &file_nico_nico_proto_msgTypes[596] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44094,7 +44185,7 @@ func (x *NetworkSecurityGroupPropagationObjectStatus) ProtoReflect() protoreflec // Deprecated: Use NetworkSecurityGroupPropagationObjectStatus.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroupPropagationObjectStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{594} + return file_nico_nico_proto_rawDescGZIP(), []int{596} } func (x *NetworkSecurityGroupPropagationObjectStatus) GetId() string { @@ -44142,7 +44233,7 @@ type GetNetworkSecurityGroupPropagationStatusResponse struct { func (x *GetNetworkSecurityGroupPropagationStatusResponse) Reset() { *x = GetNetworkSecurityGroupPropagationStatusResponse{} - mi := &file_nico_nico_proto_msgTypes[595] + mi := &file_nico_nico_proto_msgTypes[597] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44154,7 +44245,7 @@ func (x *GetNetworkSecurityGroupPropagationStatusResponse) String() string { func (*GetNetworkSecurityGroupPropagationStatusResponse) ProtoMessage() {} func (x *GetNetworkSecurityGroupPropagationStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[595] + mi := &file_nico_nico_proto_msgTypes[597] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44167,7 +44258,7 @@ func (x *GetNetworkSecurityGroupPropagationStatusResponse) ProtoReflect() protor // Deprecated: Use GetNetworkSecurityGroupPropagationStatusResponse.ProtoReflect.Descriptor instead. func (*GetNetworkSecurityGroupPropagationStatusResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{595} + return file_nico_nico_proto_rawDescGZIP(), []int{597} } func (x *GetNetworkSecurityGroupPropagationStatusResponse) GetVpcs() []*NetworkSecurityGroupPropagationObjectStatus { @@ -44193,7 +44284,7 @@ type NetworkSecurityGroupIdList struct { func (x *NetworkSecurityGroupIdList) Reset() { *x = NetworkSecurityGroupIdList{} - mi := &file_nico_nico_proto_msgTypes[596] + mi := &file_nico_nico_proto_msgTypes[598] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44205,7 +44296,7 @@ func (x *NetworkSecurityGroupIdList) String() string { func (*NetworkSecurityGroupIdList) ProtoMessage() {} func (x *NetworkSecurityGroupIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[596] + mi := &file_nico_nico_proto_msgTypes[598] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44218,7 +44309,7 @@ func (x *NetworkSecurityGroupIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkSecurityGroupIdList.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroupIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{596} + return file_nico_nico_proto_rawDescGZIP(), []int{598} } func (x *NetworkSecurityGroupIdList) GetIds() []string { @@ -44250,7 +44341,7 @@ type GetNetworkSecurityGroupPropagationStatusRequest struct { func (x *GetNetworkSecurityGroupPropagationStatusRequest) Reset() { *x = GetNetworkSecurityGroupPropagationStatusRequest{} - mi := &file_nico_nico_proto_msgTypes[597] + mi := &file_nico_nico_proto_msgTypes[599] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44262,7 +44353,7 @@ func (x *GetNetworkSecurityGroupPropagationStatusRequest) String() string { func (*GetNetworkSecurityGroupPropagationStatusRequest) ProtoMessage() {} func (x *GetNetworkSecurityGroupPropagationStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[597] + mi := &file_nico_nico_proto_msgTypes[599] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44275,7 +44366,7 @@ func (x *GetNetworkSecurityGroupPropagationStatusRequest) ProtoReflect() protore // Deprecated: Use GetNetworkSecurityGroupPropagationStatusRequest.ProtoReflect.Descriptor instead. func (*GetNetworkSecurityGroupPropagationStatusRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{597} + return file_nico_nico_proto_rawDescGZIP(), []int{599} } func (x *GetNetworkSecurityGroupPropagationStatusRequest) GetVpcIds() []string { @@ -44327,7 +44418,7 @@ type NetworkSecurityGroupRuleAttributes struct { func (x *NetworkSecurityGroupRuleAttributes) Reset() { *x = NetworkSecurityGroupRuleAttributes{} - mi := &file_nico_nico_proto_msgTypes[598] + mi := &file_nico_nico_proto_msgTypes[600] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44339,7 +44430,7 @@ func (x *NetworkSecurityGroupRuleAttributes) String() string { func (*NetworkSecurityGroupRuleAttributes) ProtoMessage() {} func (x *NetworkSecurityGroupRuleAttributes) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[598] + mi := &file_nico_nico_proto_msgTypes[600] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44352,7 +44443,7 @@ func (x *NetworkSecurityGroupRuleAttributes) ProtoReflect() protoreflect.Message // Deprecated: Use NetworkSecurityGroupRuleAttributes.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroupRuleAttributes) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{598} + return file_nico_nico_proto_rawDescGZIP(), []int{600} } func (x *NetworkSecurityGroupRuleAttributes) GetId() string { @@ -44496,7 +44587,7 @@ type ResolvedNetworkSecurityGroupRule struct { func (x *ResolvedNetworkSecurityGroupRule) Reset() { *x = ResolvedNetworkSecurityGroupRule{} - mi := &file_nico_nico_proto_msgTypes[599] + mi := &file_nico_nico_proto_msgTypes[601] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44508,7 +44599,7 @@ func (x *ResolvedNetworkSecurityGroupRule) String() string { func (*ResolvedNetworkSecurityGroupRule) ProtoMessage() {} func (x *ResolvedNetworkSecurityGroupRule) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[599] + mi := &file_nico_nico_proto_msgTypes[601] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44521,7 +44612,7 @@ func (x *ResolvedNetworkSecurityGroupRule) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolvedNetworkSecurityGroupRule.ProtoReflect.Descriptor instead. func (*ResolvedNetworkSecurityGroupRule) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{599} + return file_nico_nico_proto_rawDescGZIP(), []int{601} } func (x *ResolvedNetworkSecurityGroupRule) GetRule() *NetworkSecurityGroupRuleAttributes { @@ -44554,7 +44645,7 @@ type GetNetworkSecurityGroupAttachmentsRequest struct { func (x *GetNetworkSecurityGroupAttachmentsRequest) Reset() { *x = GetNetworkSecurityGroupAttachmentsRequest{} - mi := &file_nico_nico_proto_msgTypes[600] + mi := &file_nico_nico_proto_msgTypes[602] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44566,7 +44657,7 @@ func (x *GetNetworkSecurityGroupAttachmentsRequest) String() string { func (*GetNetworkSecurityGroupAttachmentsRequest) ProtoMessage() {} func (x *GetNetworkSecurityGroupAttachmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[600] + mi := &file_nico_nico_proto_msgTypes[602] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44579,7 +44670,7 @@ func (x *GetNetworkSecurityGroupAttachmentsRequest) ProtoReflect() protoreflect. // Deprecated: Use GetNetworkSecurityGroupAttachmentsRequest.ProtoReflect.Descriptor instead. func (*GetNetworkSecurityGroupAttachmentsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{600} + return file_nico_nico_proto_rawDescGZIP(), []int{602} } func (x *GetNetworkSecurityGroupAttachmentsRequest) GetNetworkSecurityGroupIds() []string { @@ -44600,7 +44691,7 @@ type NetworkSecurityGroupAttachments struct { func (x *NetworkSecurityGroupAttachments) Reset() { *x = NetworkSecurityGroupAttachments{} - mi := &file_nico_nico_proto_msgTypes[601] + mi := &file_nico_nico_proto_msgTypes[603] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44612,7 +44703,7 @@ func (x *NetworkSecurityGroupAttachments) String() string { func (*NetworkSecurityGroupAttachments) ProtoMessage() {} func (x *NetworkSecurityGroupAttachments) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[601] + mi := &file_nico_nico_proto_msgTypes[603] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44625,7 +44716,7 @@ func (x *NetworkSecurityGroupAttachments) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkSecurityGroupAttachments.ProtoReflect.Descriptor instead. func (*NetworkSecurityGroupAttachments) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{601} + return file_nico_nico_proto_rawDescGZIP(), []int{603} } func (x *NetworkSecurityGroupAttachments) GetNetworkSecurityGroupId() string { @@ -44658,7 +44749,7 @@ type GetNetworkSecurityGroupAttachmentsResponse struct { func (x *GetNetworkSecurityGroupAttachmentsResponse) Reset() { *x = GetNetworkSecurityGroupAttachmentsResponse{} - mi := &file_nico_nico_proto_msgTypes[602] + mi := &file_nico_nico_proto_msgTypes[604] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44670,7 +44761,7 @@ func (x *GetNetworkSecurityGroupAttachmentsResponse) String() string { func (*GetNetworkSecurityGroupAttachmentsResponse) ProtoMessage() {} func (x *GetNetworkSecurityGroupAttachmentsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[602] + mi := &file_nico_nico_proto_msgTypes[604] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44683,7 +44774,7 @@ func (x *GetNetworkSecurityGroupAttachmentsResponse) ProtoReflect() protoreflect // Deprecated: Use GetNetworkSecurityGroupAttachmentsResponse.ProtoReflect.Descriptor instead. func (*GetNetworkSecurityGroupAttachmentsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{602} + return file_nico_nico_proto_rawDescGZIP(), []int{604} } func (x *GetNetworkSecurityGroupAttachmentsResponse) GetAttachments() []*NetworkSecurityGroupAttachments { @@ -44701,7 +44792,7 @@ type GetDesiredFirmwareVersionsRequest struct { func (x *GetDesiredFirmwareVersionsRequest) Reset() { *x = GetDesiredFirmwareVersionsRequest{} - mi := &file_nico_nico_proto_msgTypes[603] + mi := &file_nico_nico_proto_msgTypes[605] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44713,7 +44804,7 @@ func (x *GetDesiredFirmwareVersionsRequest) String() string { func (*GetDesiredFirmwareVersionsRequest) ProtoMessage() {} func (x *GetDesiredFirmwareVersionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[603] + mi := &file_nico_nico_proto_msgTypes[605] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44726,7 +44817,7 @@ func (x *GetDesiredFirmwareVersionsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use GetDesiredFirmwareVersionsRequest.ProtoReflect.Descriptor instead. func (*GetDesiredFirmwareVersionsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{603} + return file_nico_nico_proto_rawDescGZIP(), []int{605} } type GetDesiredFirmwareVersionsResponse struct { @@ -44738,7 +44829,7 @@ type GetDesiredFirmwareVersionsResponse struct { func (x *GetDesiredFirmwareVersionsResponse) Reset() { *x = GetDesiredFirmwareVersionsResponse{} - mi := &file_nico_nico_proto_msgTypes[604] + mi := &file_nico_nico_proto_msgTypes[606] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44750,7 +44841,7 @@ func (x *GetDesiredFirmwareVersionsResponse) String() string { func (*GetDesiredFirmwareVersionsResponse) ProtoMessage() {} func (x *GetDesiredFirmwareVersionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[604] + mi := &file_nico_nico_proto_msgTypes[606] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44763,7 +44854,7 @@ func (x *GetDesiredFirmwareVersionsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use GetDesiredFirmwareVersionsResponse.ProtoReflect.Descriptor instead. func (*GetDesiredFirmwareVersionsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{604} + return file_nico_nico_proto_rawDescGZIP(), []int{606} } func (x *GetDesiredFirmwareVersionsResponse) GetEntries() []*DesiredFirmwareVersionEntry { @@ -44784,7 +44875,7 @@ type DesiredFirmwareVersionEntry struct { func (x *DesiredFirmwareVersionEntry) Reset() { *x = DesiredFirmwareVersionEntry{} - mi := &file_nico_nico_proto_msgTypes[605] + mi := &file_nico_nico_proto_msgTypes[607] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44796,7 +44887,7 @@ func (x *DesiredFirmwareVersionEntry) String() string { func (*DesiredFirmwareVersionEntry) ProtoMessage() {} func (x *DesiredFirmwareVersionEntry) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[605] + mi := &file_nico_nico_proto_msgTypes[607] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44809,7 +44900,7 @@ func (x *DesiredFirmwareVersionEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DesiredFirmwareVersionEntry.ProtoReflect.Descriptor instead. func (*DesiredFirmwareVersionEntry) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{605} + return file_nico_nico_proto_rawDescGZIP(), []int{607} } func (x *DesiredFirmwareVersionEntry) GetVendor() string { @@ -44844,7 +44935,7 @@ type SkuComponentChassis struct { func (x *SkuComponentChassis) Reset() { *x = SkuComponentChassis{} - mi := &file_nico_nico_proto_msgTypes[606] + mi := &file_nico_nico_proto_msgTypes[608] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44856,7 +44947,7 @@ func (x *SkuComponentChassis) String() string { func (*SkuComponentChassis) ProtoMessage() {} func (x *SkuComponentChassis) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[606] + mi := &file_nico_nico_proto_msgTypes[608] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44869,7 +44960,7 @@ func (x *SkuComponentChassis) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentChassis.ProtoReflect.Descriptor instead. func (*SkuComponentChassis) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{606} + return file_nico_nico_proto_rawDescGZIP(), []int{608} } func (x *SkuComponentChassis) GetVendor() string { @@ -44905,7 +44996,7 @@ type SkuComponentCpu struct { func (x *SkuComponentCpu) Reset() { *x = SkuComponentCpu{} - mi := &file_nico_nico_proto_msgTypes[607] + mi := &file_nico_nico_proto_msgTypes[609] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44917,7 +45008,7 @@ func (x *SkuComponentCpu) String() string { func (*SkuComponentCpu) ProtoMessage() {} func (x *SkuComponentCpu) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[607] + mi := &file_nico_nico_proto_msgTypes[609] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44930,7 +45021,7 @@ func (x *SkuComponentCpu) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentCpu.ProtoReflect.Descriptor instead. func (*SkuComponentCpu) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{607} + return file_nico_nico_proto_rawDescGZIP(), []int{609} } func (x *SkuComponentCpu) GetVendor() string { @@ -44973,7 +45064,7 @@ type SkuComponentGpu struct { func (x *SkuComponentGpu) Reset() { *x = SkuComponentGpu{} - mi := &file_nico_nico_proto_msgTypes[608] + mi := &file_nico_nico_proto_msgTypes[610] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -44985,7 +45076,7 @@ func (x *SkuComponentGpu) String() string { func (*SkuComponentGpu) ProtoMessage() {} func (x *SkuComponentGpu) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[608] + mi := &file_nico_nico_proto_msgTypes[610] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -44998,7 +45089,7 @@ func (x *SkuComponentGpu) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentGpu.ProtoReflect.Descriptor instead. func (*SkuComponentGpu) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{608} + return file_nico_nico_proto_rawDescGZIP(), []int{610} } func (x *SkuComponentGpu) GetVendor() string { @@ -45041,7 +45132,7 @@ type SkuComponentEthernetDevices struct { func (x *SkuComponentEthernetDevices) Reset() { *x = SkuComponentEthernetDevices{} - mi := &file_nico_nico_proto_msgTypes[609] + mi := &file_nico_nico_proto_msgTypes[611] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45053,7 +45144,7 @@ func (x *SkuComponentEthernetDevices) String() string { func (*SkuComponentEthernetDevices) ProtoMessage() {} func (x *SkuComponentEthernetDevices) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[609] + mi := &file_nico_nico_proto_msgTypes[611] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45066,7 +45157,7 @@ func (x *SkuComponentEthernetDevices) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentEthernetDevices.ProtoReflect.Descriptor instead. func (*SkuComponentEthernetDevices) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{609} + return file_nico_nico_proto_rawDescGZIP(), []int{611} } func (x *SkuComponentEthernetDevices) GetVendor() string { @@ -45120,7 +45211,7 @@ type SkuComponentInfinibandDevices struct { func (x *SkuComponentInfinibandDevices) Reset() { *x = SkuComponentInfinibandDevices{} - mi := &file_nico_nico_proto_msgTypes[610] + mi := &file_nico_nico_proto_msgTypes[612] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45132,7 +45223,7 @@ func (x *SkuComponentInfinibandDevices) String() string { func (*SkuComponentInfinibandDevices) ProtoMessage() {} func (x *SkuComponentInfinibandDevices) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[610] + mi := &file_nico_nico_proto_msgTypes[612] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45145,7 +45236,7 @@ func (x *SkuComponentInfinibandDevices) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentInfinibandDevices.ProtoReflect.Descriptor instead. func (*SkuComponentInfinibandDevices) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{610} + return file_nico_nico_proto_rawDescGZIP(), []int{612} } func (x *SkuComponentInfinibandDevices) GetVendor() string { @@ -45191,7 +45282,7 @@ type SkuComponentStorage struct { func (x *SkuComponentStorage) Reset() { *x = SkuComponentStorage{} - mi := &file_nico_nico_proto_msgTypes[611] + mi := &file_nico_nico_proto_msgTypes[613] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45203,7 +45294,7 @@ func (x *SkuComponentStorage) String() string { func (*SkuComponentStorage) ProtoMessage() {} func (x *SkuComponentStorage) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[611] + mi := &file_nico_nico_proto_msgTypes[613] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45216,7 +45307,7 @@ func (x *SkuComponentStorage) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentStorage.ProtoReflect.Descriptor instead. func (*SkuComponentStorage) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{611} + return file_nico_nico_proto_rawDescGZIP(), []int{613} } func (x *SkuComponentStorage) GetVendor() string { @@ -45279,7 +45370,7 @@ type SkuComponentStorageController struct { func (x *SkuComponentStorageController) Reset() { *x = SkuComponentStorageController{} - mi := &file_nico_nico_proto_msgTypes[612] + mi := &file_nico_nico_proto_msgTypes[614] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45291,7 +45382,7 @@ func (x *SkuComponentStorageController) String() string { func (*SkuComponentStorageController) ProtoMessage() {} func (x *SkuComponentStorageController) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[612] + mi := &file_nico_nico_proto_msgTypes[614] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45304,7 +45395,7 @@ func (x *SkuComponentStorageController) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentStorageController.ProtoReflect.Descriptor instead. func (*SkuComponentStorageController) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{612} + return file_nico_nico_proto_rawDescGZIP(), []int{614} } func (x *SkuComponentStorageController) GetVendor() string { @@ -45339,7 +45430,7 @@ type SkuComponentMemory struct { func (x *SkuComponentMemory) Reset() { *x = SkuComponentMemory{} - mi := &file_nico_nico_proto_msgTypes[613] + mi := &file_nico_nico_proto_msgTypes[615] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45351,7 +45442,7 @@ func (x *SkuComponentMemory) String() string { func (*SkuComponentMemory) ProtoMessage() {} func (x *SkuComponentMemory) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[613] + mi := &file_nico_nico_proto_msgTypes[615] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45364,7 +45455,7 @@ func (x *SkuComponentMemory) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentMemory.ProtoReflect.Descriptor instead. func (*SkuComponentMemory) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{613} + return file_nico_nico_proto_rawDescGZIP(), []int{615} } func (x *SkuComponentMemory) GetMemoryType() string { @@ -45398,7 +45489,7 @@ type SkuComponentTpm struct { func (x *SkuComponentTpm) Reset() { *x = SkuComponentTpm{} - mi := &file_nico_nico_proto_msgTypes[614] + mi := &file_nico_nico_proto_msgTypes[616] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45410,7 +45501,7 @@ func (x *SkuComponentTpm) String() string { func (*SkuComponentTpm) ProtoMessage() {} func (x *SkuComponentTpm) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[614] + mi := &file_nico_nico_proto_msgTypes[616] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45423,7 +45514,7 @@ func (x *SkuComponentTpm) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponentTpm.ProtoReflect.Descriptor instead. func (*SkuComponentTpm) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{614} + return file_nico_nico_proto_rawDescGZIP(), []int{616} } func (x *SkuComponentTpm) GetVendor() string { @@ -45456,7 +45547,7 @@ type SkuComponents struct { func (x *SkuComponents) Reset() { *x = SkuComponents{} - mi := &file_nico_nico_proto_msgTypes[615] + mi := &file_nico_nico_proto_msgTypes[617] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45468,7 +45559,7 @@ func (x *SkuComponents) String() string { func (*SkuComponents) ProtoMessage() {} func (x *SkuComponents) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[615] + mi := &file_nico_nico_proto_msgTypes[617] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45481,7 +45572,7 @@ func (x *SkuComponents) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuComponents.ProtoReflect.Descriptor instead. func (*SkuComponents) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{615} + return file_nico_nico_proto_rawDescGZIP(), []int{617} } func (x *SkuComponents) GetChassis() *SkuComponentChassis { @@ -45555,7 +45646,7 @@ type Sku struct { func (x *Sku) Reset() { *x = Sku{} - mi := &file_nico_nico_proto_msgTypes[616] + mi := &file_nico_nico_proto_msgTypes[618] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45567,7 +45658,7 @@ func (x *Sku) String() string { func (*Sku) ProtoMessage() {} func (x *Sku) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[616] + mi := &file_nico_nico_proto_msgTypes[618] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45580,7 +45671,7 @@ func (x *Sku) ProtoReflect() protoreflect.Message { // Deprecated: Use Sku.ProtoReflect.Descriptor instead. func (*Sku) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{616} + return file_nico_nico_proto_rawDescGZIP(), []int{618} } func (x *Sku) GetId() string { @@ -45643,7 +45734,7 @@ type SkuMachinePair struct { func (x *SkuMachinePair) Reset() { *x = SkuMachinePair{} - mi := &file_nico_nico_proto_msgTypes[617] + mi := &file_nico_nico_proto_msgTypes[619] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45655,7 +45746,7 @@ func (x *SkuMachinePair) String() string { func (*SkuMachinePair) ProtoMessage() {} func (x *SkuMachinePair) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[617] + mi := &file_nico_nico_proto_msgTypes[619] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45668,7 +45759,7 @@ func (x *SkuMachinePair) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuMachinePair.ProtoReflect.Descriptor instead. func (*SkuMachinePair) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{617} + return file_nico_nico_proto_rawDescGZIP(), []int{619} } func (x *SkuMachinePair) GetSkuId() string { @@ -45702,7 +45793,7 @@ type RemoveSkuRequest struct { func (x *RemoveSkuRequest) Reset() { *x = RemoveSkuRequest{} - mi := &file_nico_nico_proto_msgTypes[618] + mi := &file_nico_nico_proto_msgTypes[620] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45714,7 +45805,7 @@ func (x *RemoveSkuRequest) String() string { func (*RemoveSkuRequest) ProtoMessage() {} func (x *RemoveSkuRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[618] + mi := &file_nico_nico_proto_msgTypes[620] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45727,7 +45818,7 @@ func (x *RemoveSkuRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveSkuRequest.ProtoReflect.Descriptor instead. func (*RemoveSkuRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{618} + return file_nico_nico_proto_rawDescGZIP(), []int{620} } func (x *RemoveSkuRequest) GetMachineId() *MachineId { @@ -45753,7 +45844,7 @@ type SkuList struct { func (x *SkuList) Reset() { *x = SkuList{} - mi := &file_nico_nico_proto_msgTypes[619] + mi := &file_nico_nico_proto_msgTypes[621] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45765,7 +45856,7 @@ func (x *SkuList) String() string { func (*SkuList) ProtoMessage() {} func (x *SkuList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[619] + mi := &file_nico_nico_proto_msgTypes[621] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45778,7 +45869,7 @@ func (x *SkuList) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuList.ProtoReflect.Descriptor instead. func (*SkuList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{619} + return file_nico_nico_proto_rawDescGZIP(), []int{621} } func (x *SkuList) GetSkus() []*Sku { @@ -45797,7 +45888,7 @@ type SkuIdList struct { func (x *SkuIdList) Reset() { *x = SkuIdList{} - mi := &file_nico_nico_proto_msgTypes[620] + mi := &file_nico_nico_proto_msgTypes[622] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45809,7 +45900,7 @@ func (x *SkuIdList) String() string { func (*SkuIdList) ProtoMessage() {} func (x *SkuIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[620] + mi := &file_nico_nico_proto_msgTypes[622] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45822,7 +45913,7 @@ func (x *SkuIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuIdList.ProtoReflect.Descriptor instead. func (*SkuIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{620} + return file_nico_nico_proto_rawDescGZIP(), []int{622} } func (x *SkuIdList) GetIds() []string { @@ -45843,7 +45934,7 @@ type SkuStatus struct { func (x *SkuStatus) Reset() { *x = SkuStatus{} - mi := &file_nico_nico_proto_msgTypes[621] + mi := &file_nico_nico_proto_msgTypes[623] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45855,7 +45946,7 @@ func (x *SkuStatus) String() string { func (*SkuStatus) ProtoMessage() {} func (x *SkuStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[621] + mi := &file_nico_nico_proto_msgTypes[623] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45868,7 +45959,7 @@ func (x *SkuStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuStatus.ProtoReflect.Descriptor instead. func (*SkuStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{621} + return file_nico_nico_proto_rawDescGZIP(), []int{623} } func (x *SkuStatus) GetVerifyRequestTime() *timestamppb.Timestamp { @@ -45901,7 +45992,7 @@ type SkusByIdsRequest struct { func (x *SkusByIdsRequest) Reset() { *x = SkusByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[622] + mi := &file_nico_nico_proto_msgTypes[624] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45913,7 +46004,7 @@ func (x *SkusByIdsRequest) String() string { func (*SkusByIdsRequest) ProtoMessage() {} func (x *SkusByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[622] + mi := &file_nico_nico_proto_msgTypes[624] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45926,7 +46017,7 @@ func (x *SkusByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SkusByIdsRequest.ProtoReflect.Descriptor instead. func (*SkusByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{622} + return file_nico_nico_proto_rawDescGZIP(), []int{624} } func (x *SkusByIdsRequest) GetIds() []string { @@ -45944,7 +46035,7 @@ type SkuSearchFilter struct { func (x *SkuSearchFilter) Reset() { *x = SkuSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[623] + mi := &file_nico_nico_proto_msgTypes[625] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -45956,7 +46047,7 @@ func (x *SkuSearchFilter) String() string { func (*SkuSearchFilter) ProtoMessage() {} func (x *SkuSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[623] + mi := &file_nico_nico_proto_msgTypes[625] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -45969,7 +46060,7 @@ func (x *SkuSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuSearchFilter.ProtoReflect.Descriptor instead. func (*SkuSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{623} + return file_nico_nico_proto_rawDescGZIP(), []int{625} } type DpaInterface struct { @@ -46009,7 +46100,7 @@ type DpaInterface struct { func (x *DpaInterface) Reset() { *x = DpaInterface{} - mi := &file_nico_nico_proto_msgTypes[624] + mi := &file_nico_nico_proto_msgTypes[626] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46021,7 +46112,7 @@ func (x *DpaInterface) String() string { func (*DpaInterface) ProtoMessage() {} func (x *DpaInterface) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[624] + mi := &file_nico_nico_proto_msgTypes[626] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46034,7 +46125,7 @@ func (x *DpaInterface) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterface.ProtoReflect.Descriptor instead. func (*DpaInterface) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{624} + return file_nico_nico_proto_rawDescGZIP(), []int{626} } func (x *DpaInterface) GetId() *DpaInterfaceId { @@ -46191,7 +46282,7 @@ type DpaInterfaceCreationRequest struct { func (x *DpaInterfaceCreationRequest) Reset() { *x = DpaInterfaceCreationRequest{} - mi := &file_nico_nico_proto_msgTypes[625] + mi := &file_nico_nico_proto_msgTypes[627] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46203,7 +46294,7 @@ func (x *DpaInterfaceCreationRequest) String() string { func (*DpaInterfaceCreationRequest) ProtoMessage() {} func (x *DpaInterfaceCreationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[625] + mi := &file_nico_nico_proto_msgTypes[627] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46216,7 +46307,7 @@ func (x *DpaInterfaceCreationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterfaceCreationRequest.ProtoReflect.Descriptor instead. func (*DpaInterfaceCreationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{625} + return file_nico_nico_proto_rawDescGZIP(), []int{627} } func (x *DpaInterfaceCreationRequest) GetMachineId() *MachineId { @@ -46270,7 +46361,7 @@ type DpaInterfaceIdList struct { func (x *DpaInterfaceIdList) Reset() { *x = DpaInterfaceIdList{} - mi := &file_nico_nico_proto_msgTypes[626] + mi := &file_nico_nico_proto_msgTypes[628] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46282,7 +46373,7 @@ func (x *DpaInterfaceIdList) String() string { func (*DpaInterfaceIdList) ProtoMessage() {} func (x *DpaInterfaceIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[626] + mi := &file_nico_nico_proto_msgTypes[628] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46295,7 +46386,7 @@ func (x *DpaInterfaceIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterfaceIdList.ProtoReflect.Descriptor instead. func (*DpaInterfaceIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{626} + return file_nico_nico_proto_rawDescGZIP(), []int{628} } func (x *DpaInterfaceIdList) GetIds() []*DpaInterfaceId { @@ -46315,7 +46406,7 @@ type DpaInterfacesByIdsRequest struct { func (x *DpaInterfacesByIdsRequest) Reset() { *x = DpaInterfacesByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[627] + mi := &file_nico_nico_proto_msgTypes[629] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46327,7 +46418,7 @@ func (x *DpaInterfacesByIdsRequest) String() string { func (*DpaInterfacesByIdsRequest) ProtoMessage() {} func (x *DpaInterfacesByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[627] + mi := &file_nico_nico_proto_msgTypes[629] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46340,7 +46431,7 @@ func (x *DpaInterfacesByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterfacesByIdsRequest.ProtoReflect.Descriptor instead. func (*DpaInterfacesByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{627} + return file_nico_nico_proto_rawDescGZIP(), []int{629} } func (x *DpaInterfacesByIdsRequest) GetIds() []*DpaInterfaceId { @@ -46366,7 +46457,7 @@ type DpaInterfaceList struct { func (x *DpaInterfaceList) Reset() { *x = DpaInterfaceList{} - mi := &file_nico_nico_proto_msgTypes[628] + mi := &file_nico_nico_proto_msgTypes[630] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46378,7 +46469,7 @@ func (x *DpaInterfaceList) String() string { func (*DpaInterfaceList) ProtoMessage() {} func (x *DpaInterfaceList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[628] + mi := &file_nico_nico_proto_msgTypes[630] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46391,7 +46482,7 @@ func (x *DpaInterfaceList) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterfaceList.ProtoReflect.Descriptor instead. func (*DpaInterfaceList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{628} + return file_nico_nico_proto_rawDescGZIP(), []int{630} } func (x *DpaInterfaceList) GetInterfaces() []*DpaInterface { @@ -46410,7 +46501,7 @@ type DpaNetworkObservationSetRequest struct { func (x *DpaNetworkObservationSetRequest) Reset() { *x = DpaNetworkObservationSetRequest{} - mi := &file_nico_nico_proto_msgTypes[629] + mi := &file_nico_nico_proto_msgTypes[631] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46422,7 +46513,7 @@ func (x *DpaNetworkObservationSetRequest) String() string { func (*DpaNetworkObservationSetRequest) ProtoMessage() {} func (x *DpaNetworkObservationSetRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[629] + mi := &file_nico_nico_proto_msgTypes[631] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46435,7 +46526,7 @@ func (x *DpaNetworkObservationSetRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaNetworkObservationSetRequest.ProtoReflect.Descriptor instead. func (*DpaNetworkObservationSetRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{629} + return file_nico_nico_proto_rawDescGZIP(), []int{631} } func (x *DpaNetworkObservationSetRequest) GetId() *DpaInterfaceId { @@ -46454,7 +46545,7 @@ type DpaInterfaceDeletionRequest struct { func (x *DpaInterfaceDeletionRequest) Reset() { *x = DpaInterfaceDeletionRequest{} - mi := &file_nico_nico_proto_msgTypes[630] + mi := &file_nico_nico_proto_msgTypes[632] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46466,7 +46557,7 @@ func (x *DpaInterfaceDeletionRequest) String() string { func (*DpaInterfaceDeletionRequest) ProtoMessage() {} func (x *DpaInterfaceDeletionRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[630] + mi := &file_nico_nico_proto_msgTypes[632] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46479,7 +46570,7 @@ func (x *DpaInterfaceDeletionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterfaceDeletionRequest.ProtoReflect.Descriptor instead. func (*DpaInterfaceDeletionRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{630} + return file_nico_nico_proto_rawDescGZIP(), []int{632} } func (x *DpaInterfaceDeletionRequest) GetId() *DpaInterfaceId { @@ -46497,7 +46588,7 @@ type DpaInterfaceDeletionResult struct { func (x *DpaInterfaceDeletionResult) Reset() { *x = DpaInterfaceDeletionResult{} - mi := &file_nico_nico_proto_msgTypes[631] + mi := &file_nico_nico_proto_msgTypes[633] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46509,7 +46600,7 @@ func (x *DpaInterfaceDeletionResult) String() string { func (*DpaInterfaceDeletionResult) ProtoMessage() {} func (x *DpaInterfaceDeletionResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[631] + mi := &file_nico_nico_proto_msgTypes[633] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46522,7 +46613,7 @@ func (x *DpaInterfaceDeletionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use DpaInterfaceDeletionResult.ProtoReflect.Descriptor instead. func (*DpaInterfaceDeletionResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{631} + return file_nico_nico_proto_rawDescGZIP(), []int{633} } type SkuUpdateMetadataRequest struct { @@ -46536,7 +46627,7 @@ type SkuUpdateMetadataRequest struct { func (x *SkuUpdateMetadataRequest) Reset() { *x = SkuUpdateMetadataRequest{} - mi := &file_nico_nico_proto_msgTypes[632] + mi := &file_nico_nico_proto_msgTypes[634] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46548,7 +46639,7 @@ func (x *SkuUpdateMetadataRequest) String() string { func (*SkuUpdateMetadataRequest) ProtoMessage() {} func (x *SkuUpdateMetadataRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[632] + mi := &file_nico_nico_proto_msgTypes[634] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46561,7 +46652,7 @@ func (x *SkuUpdateMetadataRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SkuUpdateMetadataRequest.ProtoReflect.Descriptor instead. func (*SkuUpdateMetadataRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{632} + return file_nico_nico_proto_rawDescGZIP(), []int{634} } func (x *SkuUpdateMetadataRequest) GetSkuId() string { @@ -46594,7 +46685,7 @@ type PowerOptionRequest struct { func (x *PowerOptionRequest) Reset() { *x = PowerOptionRequest{} - mi := &file_nico_nico_proto_msgTypes[633] + mi := &file_nico_nico_proto_msgTypes[635] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46606,7 +46697,7 @@ func (x *PowerOptionRequest) String() string { func (*PowerOptionRequest) ProtoMessage() {} func (x *PowerOptionRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[633] + mi := &file_nico_nico_proto_msgTypes[635] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46619,7 +46710,7 @@ func (x *PowerOptionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PowerOptionRequest.ProtoReflect.Descriptor instead. func (*PowerOptionRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{633} + return file_nico_nico_proto_rawDescGZIP(), []int{635} } func (x *PowerOptionRequest) GetMachineId() []*MachineId { @@ -46639,7 +46730,7 @@ type PowerOptionUpdateRequest struct { func (x *PowerOptionUpdateRequest) Reset() { *x = PowerOptionUpdateRequest{} - mi := &file_nico_nico_proto_msgTypes[634] + mi := &file_nico_nico_proto_msgTypes[636] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46651,7 +46742,7 @@ func (x *PowerOptionUpdateRequest) String() string { func (*PowerOptionUpdateRequest) ProtoMessage() {} func (x *PowerOptionUpdateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[634] + mi := &file_nico_nico_proto_msgTypes[636] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46664,7 +46755,7 @@ func (x *PowerOptionUpdateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PowerOptionUpdateRequest.ProtoReflect.Descriptor instead. func (*PowerOptionUpdateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{634} + return file_nico_nico_proto_rawDescGZIP(), []int{636} } func (x *PowerOptionUpdateRequest) GetMachineId() *MachineId { @@ -46700,7 +46791,7 @@ type PowerOptions struct { func (x *PowerOptions) Reset() { *x = PowerOptions{} - mi := &file_nico_nico_proto_msgTypes[635] + mi := &file_nico_nico_proto_msgTypes[637] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46712,7 +46803,7 @@ func (x *PowerOptions) String() string { func (*PowerOptions) ProtoMessage() {} func (x *PowerOptions) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[635] + mi := &file_nico_nico_proto_msgTypes[637] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46725,7 +46816,7 @@ func (x *PowerOptions) ProtoReflect() protoreflect.Message { // Deprecated: Use PowerOptions.ProtoReflect.Descriptor instead. func (*PowerOptions) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{635} + return file_nico_nico_proto_rawDescGZIP(), []int{637} } func (x *PowerOptions) GetDesiredState() PowerState { @@ -46814,7 +46905,7 @@ type PowerOptionResponse struct { func (x *PowerOptionResponse) Reset() { *x = PowerOptionResponse{} - mi := &file_nico_nico_proto_msgTypes[636] + mi := &file_nico_nico_proto_msgTypes[638] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46826,7 +46917,7 @@ func (x *PowerOptionResponse) String() string { func (*PowerOptionResponse) ProtoMessage() {} func (x *PowerOptionResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[636] + mi := &file_nico_nico_proto_msgTypes[638] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46839,7 +46930,7 @@ func (x *PowerOptionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PowerOptionResponse.ProtoReflect.Descriptor instead. func (*PowerOptionResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{636} + return file_nico_nico_proto_rawDescGZIP(), []int{638} } func (x *PowerOptionResponse) GetResponse() []*PowerOptions { @@ -46865,7 +46956,7 @@ type ComputeAllocationAttributes struct { func (x *ComputeAllocationAttributes) Reset() { *x = ComputeAllocationAttributes{} - mi := &file_nico_nico_proto_msgTypes[637] + mi := &file_nico_nico_proto_msgTypes[639] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46877,7 +46968,7 @@ func (x *ComputeAllocationAttributes) String() string { func (*ComputeAllocationAttributes) ProtoMessage() {} func (x *ComputeAllocationAttributes) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[637] + mi := &file_nico_nico_proto_msgTypes[639] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46890,7 +46981,7 @@ func (x *ComputeAllocationAttributes) ProtoReflect() protoreflect.Message { // Deprecated: Use ComputeAllocationAttributes.ProtoReflect.Descriptor instead. func (*ComputeAllocationAttributes) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{637} + return file_nico_nico_proto_rawDescGZIP(), []int{639} } func (x *ComputeAllocationAttributes) GetInstanceTypeId() string { @@ -46923,7 +47014,7 @@ type ComputeAllocation struct { func (x *ComputeAllocation) Reset() { *x = ComputeAllocation{} - mi := &file_nico_nico_proto_msgTypes[638] + mi := &file_nico_nico_proto_msgTypes[640] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -46935,7 +47026,7 @@ func (x *ComputeAllocation) String() string { func (*ComputeAllocation) ProtoMessage() {} func (x *ComputeAllocation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[638] + mi := &file_nico_nico_proto_msgTypes[640] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -46948,7 +47039,7 @@ func (x *ComputeAllocation) ProtoReflect() protoreflect.Message { // Deprecated: Use ComputeAllocation.ProtoReflect.Descriptor instead. func (*ComputeAllocation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{638} + return file_nico_nico_proto_rawDescGZIP(), []int{640} } func (x *ComputeAllocation) GetId() *ComputeAllocationId { @@ -47020,7 +47111,7 @@ type CreateComputeAllocationRequest struct { func (x *CreateComputeAllocationRequest) Reset() { *x = CreateComputeAllocationRequest{} - mi := &file_nico_nico_proto_msgTypes[639] + mi := &file_nico_nico_proto_msgTypes[641] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47032,7 +47123,7 @@ func (x *CreateComputeAllocationRequest) String() string { func (*CreateComputeAllocationRequest) ProtoMessage() {} func (x *CreateComputeAllocationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[639] + mi := &file_nico_nico_proto_msgTypes[641] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47045,7 +47136,7 @@ func (x *CreateComputeAllocationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateComputeAllocationRequest.ProtoReflect.Descriptor instead. func (*CreateComputeAllocationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{639} + return file_nico_nico_proto_rawDescGZIP(), []int{641} } func (x *CreateComputeAllocationRequest) GetId() *ComputeAllocationId { @@ -47092,7 +47183,7 @@ type CreateComputeAllocationResponse struct { func (x *CreateComputeAllocationResponse) Reset() { *x = CreateComputeAllocationResponse{} - mi := &file_nico_nico_proto_msgTypes[640] + mi := &file_nico_nico_proto_msgTypes[642] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47104,7 +47195,7 @@ func (x *CreateComputeAllocationResponse) String() string { func (*CreateComputeAllocationResponse) ProtoMessage() {} func (x *CreateComputeAllocationResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[640] + mi := &file_nico_nico_proto_msgTypes[642] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47117,7 +47208,7 @@ func (x *CreateComputeAllocationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateComputeAllocationResponse.ProtoReflect.Descriptor instead. func (*CreateComputeAllocationResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{640} + return file_nico_nico_proto_rawDescGZIP(), []int{642} } func (x *CreateComputeAllocationResponse) GetAllocation() *ComputeAllocation { @@ -47144,7 +47235,7 @@ type FindComputeAllocationIdsRequest struct { func (x *FindComputeAllocationIdsRequest) Reset() { *x = FindComputeAllocationIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[641] + mi := &file_nico_nico_proto_msgTypes[643] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47156,7 +47247,7 @@ func (x *FindComputeAllocationIdsRequest) String() string { func (*FindComputeAllocationIdsRequest) ProtoMessage() {} func (x *FindComputeAllocationIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[641] + mi := &file_nico_nico_proto_msgTypes[643] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47169,7 +47260,7 @@ func (x *FindComputeAllocationIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FindComputeAllocationIdsRequest.ProtoReflect.Descriptor instead. func (*FindComputeAllocationIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{641} + return file_nico_nico_proto_rawDescGZIP(), []int{643} } func (x *FindComputeAllocationIdsRequest) GetName() string { @@ -47202,7 +47293,7 @@ type FindComputeAllocationIdsResponse struct { func (x *FindComputeAllocationIdsResponse) Reset() { *x = FindComputeAllocationIdsResponse{} - mi := &file_nico_nico_proto_msgTypes[642] + mi := &file_nico_nico_proto_msgTypes[644] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47214,7 +47305,7 @@ func (x *FindComputeAllocationIdsResponse) String() string { func (*FindComputeAllocationIdsResponse) ProtoMessage() {} func (x *FindComputeAllocationIdsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[642] + mi := &file_nico_nico_proto_msgTypes[644] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47227,7 +47318,7 @@ func (x *FindComputeAllocationIdsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FindComputeAllocationIdsResponse.ProtoReflect.Descriptor instead. func (*FindComputeAllocationIdsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{642} + return file_nico_nico_proto_rawDescGZIP(), []int{644} } func (x *FindComputeAllocationIdsResponse) GetIds() []*ComputeAllocationId { @@ -47249,7 +47340,7 @@ type FindComputeAllocationsByIdsRequest struct { func (x *FindComputeAllocationsByIdsRequest) Reset() { *x = FindComputeAllocationsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[643] + mi := &file_nico_nico_proto_msgTypes[645] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47261,7 +47352,7 @@ func (x *FindComputeAllocationsByIdsRequest) String() string { func (*FindComputeAllocationsByIdsRequest) ProtoMessage() {} func (x *FindComputeAllocationsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[643] + mi := &file_nico_nico_proto_msgTypes[645] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47274,7 +47365,7 @@ func (x *FindComputeAllocationsByIdsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use FindComputeAllocationsByIdsRequest.ProtoReflect.Descriptor instead. func (*FindComputeAllocationsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{643} + return file_nico_nico_proto_rawDescGZIP(), []int{645} } func (x *FindComputeAllocationsByIdsRequest) GetIds() []*ComputeAllocationId { @@ -47293,7 +47384,7 @@ type FindComputeAllocationsByIdsResponse struct { func (x *FindComputeAllocationsByIdsResponse) Reset() { *x = FindComputeAllocationsByIdsResponse{} - mi := &file_nico_nico_proto_msgTypes[644] + mi := &file_nico_nico_proto_msgTypes[646] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47305,7 +47396,7 @@ func (x *FindComputeAllocationsByIdsResponse) String() string { func (*FindComputeAllocationsByIdsResponse) ProtoMessage() {} func (x *FindComputeAllocationsByIdsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[644] + mi := &file_nico_nico_proto_msgTypes[646] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47318,7 +47409,7 @@ func (x *FindComputeAllocationsByIdsResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use FindComputeAllocationsByIdsResponse.ProtoReflect.Descriptor instead. func (*FindComputeAllocationsByIdsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{644} + return file_nico_nico_proto_rawDescGZIP(), []int{646} } func (x *FindComputeAllocationsByIdsResponse) GetAllocations() []*ComputeAllocation { @@ -47337,7 +47428,7 @@ type UpdateComputeAllocationResponse struct { func (x *UpdateComputeAllocationResponse) Reset() { *x = UpdateComputeAllocationResponse{} - mi := &file_nico_nico_proto_msgTypes[645] + mi := &file_nico_nico_proto_msgTypes[647] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47349,7 +47440,7 @@ func (x *UpdateComputeAllocationResponse) String() string { func (*UpdateComputeAllocationResponse) ProtoMessage() {} func (x *UpdateComputeAllocationResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[645] + mi := &file_nico_nico_proto_msgTypes[647] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47362,7 +47453,7 @@ func (x *UpdateComputeAllocationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateComputeAllocationResponse.ProtoReflect.Descriptor instead. func (*UpdateComputeAllocationResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{645} + return file_nico_nico_proto_rawDescGZIP(), []int{647} } func (x *UpdateComputeAllocationResponse) GetAllocation() *ComputeAllocation { @@ -47386,7 +47477,7 @@ type UpdateComputeAllocationRequest struct { func (x *UpdateComputeAllocationRequest) Reset() { *x = UpdateComputeAllocationRequest{} - mi := &file_nico_nico_proto_msgTypes[646] + mi := &file_nico_nico_proto_msgTypes[648] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47398,7 +47489,7 @@ func (x *UpdateComputeAllocationRequest) String() string { func (*UpdateComputeAllocationRequest) ProtoMessage() {} func (x *UpdateComputeAllocationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[646] + mi := &file_nico_nico_proto_msgTypes[648] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47411,7 +47502,7 @@ func (x *UpdateComputeAllocationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateComputeAllocationRequest.ProtoReflect.Descriptor instead. func (*UpdateComputeAllocationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{646} + return file_nico_nico_proto_rawDescGZIP(), []int{648} } func (x *UpdateComputeAllocationRequest) GetId() *ComputeAllocationId { @@ -47466,7 +47557,7 @@ type DeleteComputeAllocationRequest struct { func (x *DeleteComputeAllocationRequest) Reset() { *x = DeleteComputeAllocationRequest{} - mi := &file_nico_nico_proto_msgTypes[647] + mi := &file_nico_nico_proto_msgTypes[649] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47478,7 +47569,7 @@ func (x *DeleteComputeAllocationRequest) String() string { func (*DeleteComputeAllocationRequest) ProtoMessage() {} func (x *DeleteComputeAllocationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[647] + mi := &file_nico_nico_proto_msgTypes[649] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47491,7 +47582,7 @@ func (x *DeleteComputeAllocationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteComputeAllocationRequest.ProtoReflect.Descriptor instead. func (*DeleteComputeAllocationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{647} + return file_nico_nico_proto_rawDescGZIP(), []int{649} } func (x *DeleteComputeAllocationRequest) GetId() *ComputeAllocationId { @@ -47516,7 +47607,7 @@ type DeleteComputeAllocationResponse struct { func (x *DeleteComputeAllocationResponse) Reset() { *x = DeleteComputeAllocationResponse{} - mi := &file_nico_nico_proto_msgTypes[648] + mi := &file_nico_nico_proto_msgTypes[650] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47528,7 +47619,7 @@ func (x *DeleteComputeAllocationResponse) String() string { func (*DeleteComputeAllocationResponse) ProtoMessage() {} func (x *DeleteComputeAllocationResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[648] + mi := &file_nico_nico_proto_msgTypes[650] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47541,7 +47632,7 @@ func (x *DeleteComputeAllocationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteComputeAllocationResponse.ProtoReflect.Descriptor instead. func (*DeleteComputeAllocationResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{648} + return file_nico_nico_proto_rawDescGZIP(), []int{650} } // For use with the existing InstanceType message @@ -47566,7 +47657,7 @@ type InstanceTypeAllocationStats struct { func (x *InstanceTypeAllocationStats) Reset() { *x = InstanceTypeAllocationStats{} - mi := &file_nico_nico_proto_msgTypes[649] + mi := &file_nico_nico_proto_msgTypes[651] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47578,7 +47669,7 @@ func (x *InstanceTypeAllocationStats) String() string { func (*InstanceTypeAllocationStats) ProtoMessage() {} func (x *InstanceTypeAllocationStats) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[649] + mi := &file_nico_nico_proto_msgTypes[651] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47591,7 +47682,7 @@ func (x *InstanceTypeAllocationStats) ProtoReflect() protoreflect.Message { // Deprecated: Use InstanceTypeAllocationStats.ProtoReflect.Descriptor instead. func (*InstanceTypeAllocationStats) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{649} + return file_nico_nico_proto_rawDescGZIP(), []int{651} } func (x *InstanceTypeAllocationStats) GetMaxAllocatable() uint32 { @@ -47631,7 +47722,7 @@ type GetRackRequest struct { func (x *GetRackRequest) Reset() { *x = GetRackRequest{} - mi := &file_nico_nico_proto_msgTypes[650] + mi := &file_nico_nico_proto_msgTypes[652] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47643,7 +47734,7 @@ func (x *GetRackRequest) String() string { func (*GetRackRequest) ProtoMessage() {} func (x *GetRackRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[650] + mi := &file_nico_nico_proto_msgTypes[652] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47656,7 +47747,7 @@ func (x *GetRackRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRackRequest.ProtoReflect.Descriptor instead. func (*GetRackRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{650} + return file_nico_nico_proto_rawDescGZIP(), []int{652} } func (x *GetRackRequest) GetId() string { @@ -47675,7 +47766,7 @@ type GetRackResponse struct { func (x *GetRackResponse) Reset() { *x = GetRackResponse{} - mi := &file_nico_nico_proto_msgTypes[651] + mi := &file_nico_nico_proto_msgTypes[653] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47687,7 +47778,7 @@ func (x *GetRackResponse) String() string { func (*GetRackResponse) ProtoMessage() {} func (x *GetRackResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[651] + mi := &file_nico_nico_proto_msgTypes[653] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47700,7 +47791,7 @@ func (x *GetRackResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRackResponse.ProtoReflect.Descriptor instead. func (*GetRackResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{651} + return file_nico_nico_proto_rawDescGZIP(), []int{653} } func (x *GetRackResponse) GetRack() []*Rack { @@ -47719,7 +47810,7 @@ type RackList struct { func (x *RackList) Reset() { *x = RackList{} - mi := &file_nico_nico_proto_msgTypes[652] + mi := &file_nico_nico_proto_msgTypes[654] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47731,7 +47822,7 @@ func (x *RackList) String() string { func (*RackList) ProtoMessage() {} func (x *RackList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[652] + mi := &file_nico_nico_proto_msgTypes[654] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47744,7 +47835,7 @@ func (x *RackList) ProtoReflect() protoreflect.Message { // Deprecated: Use RackList.ProtoReflect.Descriptor instead. func (*RackList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{652} + return file_nico_nico_proto_rawDescGZIP(), []int{654} } func (x *RackList) GetRacks() []*Rack { @@ -47764,7 +47855,7 @@ type RackSearchFilter struct { func (x *RackSearchFilter) Reset() { *x = RackSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[653] + mi := &file_nico_nico_proto_msgTypes[655] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47776,7 +47867,7 @@ func (x *RackSearchFilter) String() string { func (*RackSearchFilter) ProtoMessage() {} func (x *RackSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[653] + mi := &file_nico_nico_proto_msgTypes[655] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47789,7 +47880,7 @@ func (x *RackSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use RackSearchFilter.ProtoReflect.Descriptor instead. func (*RackSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{653} + return file_nico_nico_proto_rawDescGZIP(), []int{655} } func (x *RackSearchFilter) GetLabel() *Label { @@ -47808,7 +47899,7 @@ type RackIdList struct { func (x *RackIdList) Reset() { *x = RackIdList{} - mi := &file_nico_nico_proto_msgTypes[654] + mi := &file_nico_nico_proto_msgTypes[656] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47820,7 +47911,7 @@ func (x *RackIdList) String() string { func (*RackIdList) ProtoMessage() {} func (x *RackIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[654] + mi := &file_nico_nico_proto_msgTypes[656] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47833,7 +47924,7 @@ func (x *RackIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use RackIdList.ProtoReflect.Descriptor instead. func (*RackIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{654} + return file_nico_nico_proto_rawDescGZIP(), []int{656} } func (x *RackIdList) GetRackIds() []*RackId { @@ -47852,7 +47943,7 @@ type RacksByIdsRequest struct { func (x *RacksByIdsRequest) Reset() { *x = RacksByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[655] + mi := &file_nico_nico_proto_msgTypes[657] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47864,7 +47955,7 @@ func (x *RacksByIdsRequest) String() string { func (*RacksByIdsRequest) ProtoMessage() {} func (x *RacksByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[655] + mi := &file_nico_nico_proto_msgTypes[657] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47877,7 +47968,7 @@ func (x *RacksByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RacksByIdsRequest.ProtoReflect.Descriptor instead. func (*RacksByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{655} + return file_nico_nico_proto_rawDescGZIP(), []int{657} } func (x *RacksByIdsRequest) GetRackIds() []*RackId { @@ -47905,7 +47996,7 @@ type Rack struct { func (x *Rack) Reset() { *x = Rack{} - mi := &file_nico_nico_proto_msgTypes[656] + mi := &file_nico_nico_proto_msgTypes[658] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -47917,7 +48008,7 @@ func (x *Rack) String() string { func (*Rack) ProtoMessage() {} func (x *Rack) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[656] + mi := &file_nico_nico_proto_msgTypes[658] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -47930,7 +48021,7 @@ func (x *Rack) ProtoReflect() protoreflect.Message { // Deprecated: Use Rack.ProtoReflect.Descriptor instead. func (*Rack) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{656} + return file_nico_nico_proto_rawDescGZIP(), []int{658} } func (x *Rack) GetId() *RackId { @@ -48004,7 +48095,7 @@ type RackConfig struct { func (x *RackConfig) Reset() { *x = RackConfig{} - mi := &file_nico_nico_proto_msgTypes[657] + mi := &file_nico_nico_proto_msgTypes[659] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48016,7 +48107,7 @@ func (x *RackConfig) String() string { func (*RackConfig) ProtoMessage() {} func (x *RackConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[657] + mi := &file_nico_nico_proto_msgTypes[659] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48029,7 +48120,7 @@ func (x *RackConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use RackConfig.ProtoReflect.Descriptor instead. func (*RackConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{657} + return file_nico_nico_proto_rawDescGZIP(), []int{659} } type RackStatus struct { @@ -48044,7 +48135,7 @@ type RackStatus struct { func (x *RackStatus) Reset() { *x = RackStatus{} - mi := &file_nico_nico_proto_msgTypes[658] + mi := &file_nico_nico_proto_msgTypes[660] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48056,7 +48147,7 @@ func (x *RackStatus) String() string { func (*RackStatus) ProtoMessage() {} func (x *RackStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[658] + mi := &file_nico_nico_proto_msgTypes[660] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48069,7 +48160,7 @@ func (x *RackStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use RackStatus.ProtoReflect.Descriptor instead. func (*RackStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{658} + return file_nico_nico_proto_rawDescGZIP(), []int{660} } func (x *RackStatus) GetHealth() *HealthReport { @@ -48102,7 +48193,7 @@ type RackStateHistoriesRequest struct { func (x *RackStateHistoriesRequest) Reset() { *x = RackStateHistoriesRequest{} - mi := &file_nico_nico_proto_msgTypes[659] + mi := &file_nico_nico_proto_msgTypes[661] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48114,7 +48205,7 @@ func (x *RackStateHistoriesRequest) String() string { func (*RackStateHistoriesRequest) ProtoMessage() {} func (x *RackStateHistoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[659] + mi := &file_nico_nico_proto_msgTypes[661] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48127,7 +48218,7 @@ func (x *RackStateHistoriesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RackStateHistoriesRequest.ProtoReflect.Descriptor instead. func (*RackStateHistoriesRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{659} + return file_nico_nico_proto_rawDescGZIP(), []int{661} } func (x *RackStateHistoriesRequest) GetRackIds() []*RackId { @@ -48146,7 +48237,7 @@ type DeleteRackRequest struct { func (x *DeleteRackRequest) Reset() { *x = DeleteRackRequest{} - mi := &file_nico_nico_proto_msgTypes[660] + mi := &file_nico_nico_proto_msgTypes[662] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48158,7 +48249,7 @@ func (x *DeleteRackRequest) String() string { func (*DeleteRackRequest) ProtoMessage() {} func (x *DeleteRackRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[660] + mi := &file_nico_nico_proto_msgTypes[662] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48171,7 +48262,7 @@ func (x *DeleteRackRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteRackRequest.ProtoReflect.Descriptor instead. func (*DeleteRackRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{660} + return file_nico_nico_proto_rawDescGZIP(), []int{662} } func (x *DeleteRackRequest) GetId() string { @@ -48192,7 +48283,7 @@ type AdminForceDeleteRackRequest struct { func (x *AdminForceDeleteRackRequest) Reset() { *x = AdminForceDeleteRackRequest{} - mi := &file_nico_nico_proto_msgTypes[661] + mi := &file_nico_nico_proto_msgTypes[663] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48204,7 +48295,7 @@ func (x *AdminForceDeleteRackRequest) String() string { func (*AdminForceDeleteRackRequest) ProtoMessage() {} func (x *AdminForceDeleteRackRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[661] + mi := &file_nico_nico_proto_msgTypes[663] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48217,7 +48308,7 @@ func (x *AdminForceDeleteRackRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AdminForceDeleteRackRequest.ProtoReflect.Descriptor instead. func (*AdminForceDeleteRackRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{661} + return file_nico_nico_proto_rawDescGZIP(), []int{663} } func (x *AdminForceDeleteRackRequest) GetRackId() *RackId { @@ -48237,7 +48328,7 @@ type AdminForceDeleteRackResponse struct { func (x *AdminForceDeleteRackResponse) Reset() { *x = AdminForceDeleteRackResponse{} - mi := &file_nico_nico_proto_msgTypes[662] + mi := &file_nico_nico_proto_msgTypes[664] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48249,7 +48340,7 @@ func (x *AdminForceDeleteRackResponse) String() string { func (*AdminForceDeleteRackResponse) ProtoMessage() {} func (x *AdminForceDeleteRackResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[662] + mi := &file_nico_nico_proto_msgTypes[664] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48262,7 +48353,7 @@ func (x *AdminForceDeleteRackResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AdminForceDeleteRackResponse.ProtoReflect.Descriptor instead. func (*AdminForceDeleteRackResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{662} + return file_nico_nico_proto_rawDescGZIP(), []int{664} } func (x *AdminForceDeleteRackResponse) GetRackId() string { @@ -48284,7 +48375,7 @@ type RackCapabilityCompute struct { func (x *RackCapabilityCompute) Reset() { *x = RackCapabilityCompute{} - mi := &file_nico_nico_proto_msgTypes[663] + mi := &file_nico_nico_proto_msgTypes[665] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48296,7 +48387,7 @@ func (x *RackCapabilityCompute) String() string { func (*RackCapabilityCompute) ProtoMessage() {} func (x *RackCapabilityCompute) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[663] + mi := &file_nico_nico_proto_msgTypes[665] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48309,7 +48400,7 @@ func (x *RackCapabilityCompute) ProtoReflect() protoreflect.Message { // Deprecated: Use RackCapabilityCompute.ProtoReflect.Descriptor instead. func (*RackCapabilityCompute) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{663} + return file_nico_nico_proto_rawDescGZIP(), []int{665} } func (x *RackCapabilityCompute) GetName() string { @@ -48352,7 +48443,7 @@ type RackCapabilitySwitch struct { func (x *RackCapabilitySwitch) Reset() { *x = RackCapabilitySwitch{} - mi := &file_nico_nico_proto_msgTypes[664] + mi := &file_nico_nico_proto_msgTypes[666] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48364,7 +48455,7 @@ func (x *RackCapabilitySwitch) String() string { func (*RackCapabilitySwitch) ProtoMessage() {} func (x *RackCapabilitySwitch) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[664] + mi := &file_nico_nico_proto_msgTypes[666] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48377,7 +48468,7 @@ func (x *RackCapabilitySwitch) ProtoReflect() protoreflect.Message { // Deprecated: Use RackCapabilitySwitch.ProtoReflect.Descriptor instead. func (*RackCapabilitySwitch) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{664} + return file_nico_nico_proto_rawDescGZIP(), []int{666} } func (x *RackCapabilitySwitch) GetName() string { @@ -48420,7 +48511,7 @@ type RackCapabilityPowerShelf struct { func (x *RackCapabilityPowerShelf) Reset() { *x = RackCapabilityPowerShelf{} - mi := &file_nico_nico_proto_msgTypes[665] + mi := &file_nico_nico_proto_msgTypes[667] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48432,7 +48523,7 @@ func (x *RackCapabilityPowerShelf) String() string { func (*RackCapabilityPowerShelf) ProtoMessage() {} func (x *RackCapabilityPowerShelf) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[665] + mi := &file_nico_nico_proto_msgTypes[667] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48445,7 +48536,7 @@ func (x *RackCapabilityPowerShelf) ProtoReflect() protoreflect.Message { // Deprecated: Use RackCapabilityPowerShelf.ProtoReflect.Descriptor instead. func (*RackCapabilityPowerShelf) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{665} + return file_nico_nico_proto_rawDescGZIP(), []int{667} } func (x *RackCapabilityPowerShelf) GetName() string { @@ -48487,7 +48578,7 @@ type RackCapabilitiesSet struct { func (x *RackCapabilitiesSet) Reset() { *x = RackCapabilitiesSet{} - mi := &file_nico_nico_proto_msgTypes[666] + mi := &file_nico_nico_proto_msgTypes[668] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48499,7 +48590,7 @@ func (x *RackCapabilitiesSet) String() string { func (*RackCapabilitiesSet) ProtoMessage() {} func (x *RackCapabilitiesSet) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[666] + mi := &file_nico_nico_proto_msgTypes[668] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48512,7 +48603,7 @@ func (x *RackCapabilitiesSet) ProtoReflect() protoreflect.Message { // Deprecated: Use RackCapabilitiesSet.ProtoReflect.Descriptor instead. func (*RackCapabilitiesSet) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{666} + return file_nico_nico_proto_rawDescGZIP(), []int{668} } func (x *RackCapabilitiesSet) GetCompute() *RackCapabilityCompute { @@ -48549,7 +48640,7 @@ type RackProfile struct { func (x *RackProfile) Reset() { *x = RackProfile{} - mi := &file_nico_nico_proto_msgTypes[667] + mi := &file_nico_nico_proto_msgTypes[669] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48561,7 +48652,7 @@ func (x *RackProfile) String() string { func (*RackProfile) ProtoMessage() {} func (x *RackProfile) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[667] + mi := &file_nico_nico_proto_msgTypes[669] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48574,7 +48665,7 @@ func (x *RackProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use RackProfile.ProtoReflect.Descriptor instead. func (*RackProfile) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{667} + return file_nico_nico_proto_rawDescGZIP(), []int{669} } func (x *RackProfile) GetRackHardwareType() *RackHardwareType { @@ -48621,7 +48712,7 @@ type GetRackProfileRequest struct { func (x *GetRackProfileRequest) Reset() { *x = GetRackProfileRequest{} - mi := &file_nico_nico_proto_msgTypes[668] + mi := &file_nico_nico_proto_msgTypes[670] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48633,7 +48724,7 @@ func (x *GetRackProfileRequest) String() string { func (*GetRackProfileRequest) ProtoMessage() {} func (x *GetRackProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[668] + mi := &file_nico_nico_proto_msgTypes[670] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48646,7 +48737,7 @@ func (x *GetRackProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRackProfileRequest.ProtoReflect.Descriptor instead. func (*GetRackProfileRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{668} + return file_nico_nico_proto_rawDescGZIP(), []int{670} } func (x *GetRackProfileRequest) GetRackId() *RackId { @@ -48667,7 +48758,7 @@ type GetRackProfileResponse struct { func (x *GetRackProfileResponse) Reset() { *x = GetRackProfileResponse{} - mi := &file_nico_nico_proto_msgTypes[669] + mi := &file_nico_nico_proto_msgTypes[671] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48679,7 +48770,7 @@ func (x *GetRackProfileResponse) String() string { func (*GetRackProfileResponse) ProtoMessage() {} func (x *GetRackProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[669] + mi := &file_nico_nico_proto_msgTypes[671] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48692,7 +48783,7 @@ func (x *GetRackProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetRackProfileResponse.ProtoReflect.Descriptor instead. func (*GetRackProfileResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{669} + return file_nico_nico_proto_rawDescGZIP(), []int{671} } func (x *GetRackProfileResponse) GetRackId() *RackId { @@ -48726,7 +48817,7 @@ type RackManagerForgeRequest struct { func (x *RackManagerForgeRequest) Reset() { *x = RackManagerForgeRequest{} - mi := &file_nico_nico_proto_msgTypes[670] + mi := &file_nico_nico_proto_msgTypes[672] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48738,7 +48829,7 @@ func (x *RackManagerForgeRequest) String() string { func (*RackManagerForgeRequest) ProtoMessage() {} func (x *RackManagerForgeRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[670] + mi := &file_nico_nico_proto_msgTypes[672] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48751,7 +48842,7 @@ func (x *RackManagerForgeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RackManagerForgeRequest.ProtoReflect.Descriptor instead. func (*RackManagerForgeRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{670} + return file_nico_nico_proto_rawDescGZIP(), []int{672} } func (x *RackManagerForgeRequest) GetCmd() RackManagerForgeCmd { @@ -48777,7 +48868,7 @@ type RackManagerForgeResponse struct { func (x *RackManagerForgeResponse) Reset() { *x = RackManagerForgeResponse{} - mi := &file_nico_nico_proto_msgTypes[671] + mi := &file_nico_nico_proto_msgTypes[673] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48789,7 +48880,7 @@ func (x *RackManagerForgeResponse) String() string { func (*RackManagerForgeResponse) ProtoMessage() {} func (x *RackManagerForgeResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[671] + mi := &file_nico_nico_proto_msgTypes[673] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48802,7 +48893,7 @@ func (x *RackManagerForgeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RackManagerForgeResponse.ProtoReflect.Descriptor instead. func (*RackManagerForgeResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{671} + return file_nico_nico_proto_rawDescGZIP(), []int{673} } func (x *RackManagerForgeResponse) GetJsonResult() string { @@ -48823,7 +48914,7 @@ type MachineNVLinkInfo struct { func (x *MachineNVLinkInfo) Reset() { *x = MachineNVLinkInfo{} - mi := &file_nico_nico_proto_msgTypes[672] + mi := &file_nico_nico_proto_msgTypes[674] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48835,7 +48926,7 @@ func (x *MachineNVLinkInfo) String() string { func (*MachineNVLinkInfo) ProtoMessage() {} func (x *MachineNVLinkInfo) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[672] + mi := &file_nico_nico_proto_msgTypes[674] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48848,7 +48939,7 @@ func (x *MachineNVLinkInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineNVLinkInfo.ProtoReflect.Descriptor instead. func (*MachineNVLinkInfo) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{672} + return file_nico_nico_proto_rawDescGZIP(), []int{674} } func (x *MachineNVLinkInfo) GetDomainUuid() *NVLinkDomainId { @@ -48882,7 +48973,7 @@ type UpdateMachineNvLinkInfoRequest struct { func (x *UpdateMachineNvLinkInfoRequest) Reset() { *x = UpdateMachineNvLinkInfoRequest{} - mi := &file_nico_nico_proto_msgTypes[673] + mi := &file_nico_nico_proto_msgTypes[675] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48894,7 +48985,7 @@ func (x *UpdateMachineNvLinkInfoRequest) String() string { func (*UpdateMachineNvLinkInfoRequest) ProtoMessage() {} func (x *UpdateMachineNvLinkInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[673] + mi := &file_nico_nico_proto_msgTypes[675] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48907,7 +48998,7 @@ func (x *UpdateMachineNvLinkInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateMachineNvLinkInfoRequest.ProtoReflect.Descriptor instead. func (*UpdateMachineNvLinkInfoRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{673} + return file_nico_nico_proto_rawDescGZIP(), []int{675} } func (x *UpdateMachineNvLinkInfoRequest) GetMachineId() *MachineId { @@ -48934,7 +49025,7 @@ type MachineSpxStatusObservation struct { func (x *MachineSpxStatusObservation) Reset() { *x = MachineSpxStatusObservation{} - mi := &file_nico_nico_proto_msgTypes[674] + mi := &file_nico_nico_proto_msgTypes[676] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -48946,7 +49037,7 @@ func (x *MachineSpxStatusObservation) String() string { func (*MachineSpxStatusObservation) ProtoMessage() {} func (x *MachineSpxStatusObservation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[674] + mi := &file_nico_nico_proto_msgTypes[676] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -48959,7 +49050,7 @@ func (x *MachineSpxStatusObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineSpxStatusObservation.ProtoReflect.Descriptor instead. func (*MachineSpxStatusObservation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{674} + return file_nico_nico_proto_rawDescGZIP(), []int{676} } func (x *MachineSpxStatusObservation) GetAttachmentStatus() []*MachineSpxAttachmentStatusObservation { @@ -48989,7 +49080,7 @@ type MachineSpxAttachmentStatusObservation struct { func (x *MachineSpxAttachmentStatusObservation) Reset() { *x = MachineSpxAttachmentStatusObservation{} - mi := &file_nico_nico_proto_msgTypes[675] + mi := &file_nico_nico_proto_msgTypes[677] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49001,7 +49092,7 @@ func (x *MachineSpxAttachmentStatusObservation) String() string { func (*MachineSpxAttachmentStatusObservation) ProtoMessage() {} func (x *MachineSpxAttachmentStatusObservation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[675] + mi := &file_nico_nico_proto_msgTypes[677] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49014,7 +49105,7 @@ func (x *MachineSpxAttachmentStatusObservation) ProtoReflect() protoreflect.Mess // Deprecated: Use MachineSpxAttachmentStatusObservation.ProtoReflect.Descriptor instead. func (*MachineSpxAttachmentStatusObservation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{675} + return file_nico_nico_proto_rawDescGZIP(), []int{677} } func (x *MachineSpxAttachmentStatusObservation) GetMacAddress() string { @@ -49061,7 +49152,7 @@ type AstraConfig struct { func (x *AstraConfig) Reset() { *x = AstraConfig{} - mi := &file_nico_nico_proto_msgTypes[676] + mi := &file_nico_nico_proto_msgTypes[678] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49073,7 +49164,7 @@ func (x *AstraConfig) String() string { func (*AstraConfig) ProtoMessage() {} func (x *AstraConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[676] + mi := &file_nico_nico_proto_msgTypes[678] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49086,7 +49177,7 @@ func (x *AstraConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use AstraConfig.ProtoReflect.Descriptor instead. func (*AstraConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{676} + return file_nico_nico_proto_rawDescGZIP(), []int{678} } func (x *AstraConfig) GetAstraAttachments() []*AstraAttachment { @@ -49112,7 +49203,7 @@ type AstraAttachment struct { func (x *AstraAttachment) Reset() { *x = AstraAttachment{} - mi := &file_nico_nico_proto_msgTypes[677] + mi := &file_nico_nico_proto_msgTypes[679] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49124,7 +49215,7 @@ func (x *AstraAttachment) String() string { func (*AstraAttachment) ProtoMessage() {} func (x *AstraAttachment) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[677] + mi := &file_nico_nico_proto_msgTypes[679] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49137,7 +49228,7 @@ func (x *AstraAttachment) ProtoReflect() protoreflect.Message { // Deprecated: Use AstraAttachment.ProtoReflect.Descriptor instead. func (*AstraAttachment) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{677} + return file_nico_nico_proto_rawDescGZIP(), []int{679} } func (x *AstraAttachment) GetMacAddress() string { @@ -49205,7 +49296,7 @@ type AstraConfigStatus struct { func (x *AstraConfigStatus) Reset() { *x = AstraConfigStatus{} - mi := &file_nico_nico_proto_msgTypes[678] + mi := &file_nico_nico_proto_msgTypes[680] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49217,7 +49308,7 @@ func (x *AstraConfigStatus) String() string { func (*AstraConfigStatus) ProtoMessage() {} func (x *AstraConfigStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[678] + mi := &file_nico_nico_proto_msgTypes[680] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49230,7 +49321,7 @@ func (x *AstraConfigStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use AstraConfigStatus.ProtoReflect.Descriptor instead. func (*AstraConfigStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{678} + return file_nico_nico_proto_rawDescGZIP(), []int{680} } func (x *AstraConfigStatus) GetAstraAttachmentsStatus() []*AstraAttachmentStatus { @@ -49257,7 +49348,7 @@ type AstraAttachmentStatus struct { func (x *AstraAttachmentStatus) Reset() { *x = AstraAttachmentStatus{} - mi := &file_nico_nico_proto_msgTypes[679] + mi := &file_nico_nico_proto_msgTypes[681] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49269,7 +49360,7 @@ func (x *AstraAttachmentStatus) String() string { func (*AstraAttachmentStatus) ProtoMessage() {} func (x *AstraAttachmentStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[679] + mi := &file_nico_nico_proto_msgTypes[681] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49282,7 +49373,7 @@ func (x *AstraAttachmentStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use AstraAttachmentStatus.ProtoReflect.Descriptor instead. func (*AstraAttachmentStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{679} + return file_nico_nico_proto_rawDescGZIP(), []int{681} } func (x *AstraAttachmentStatus) GetMacAddress() string { @@ -49359,7 +49450,7 @@ type AstraStatus struct { func (x *AstraStatus) Reset() { *x = AstraStatus{} - mi := &file_nico_nico_proto_msgTypes[680] + mi := &file_nico_nico_proto_msgTypes[682] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49371,7 +49462,7 @@ func (x *AstraStatus) String() string { func (*AstraStatus) ProtoMessage() {} func (x *AstraStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[680] + mi := &file_nico_nico_proto_msgTypes[682] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49384,7 +49475,7 @@ func (x *AstraStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use AstraStatus.ProtoReflect.Descriptor instead. func (*AstraStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{680} + return file_nico_nico_proto_rawDescGZIP(), []int{682} } func (x *AstraStatus) GetPhase() AstraPhase { @@ -49420,7 +49511,7 @@ type NVLinkGpu struct { func (x *NVLinkGpu) Reset() { *x = NVLinkGpu{} - mi := &file_nico_nico_proto_msgTypes[681] + mi := &file_nico_nico_proto_msgTypes[683] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49432,7 +49523,7 @@ func (x *NVLinkGpu) String() string { func (*NVLinkGpu) ProtoMessage() {} func (x *NVLinkGpu) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[681] + mi := &file_nico_nico_proto_msgTypes[683] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49445,7 +49536,7 @@ func (x *NVLinkGpu) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkGpu.ProtoReflect.Descriptor instead. func (*NVLinkGpu) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{681} + return file_nico_nico_proto_rawDescGZIP(), []int{683} } func (x *NVLinkGpu) GetTrayIndex() int32 { @@ -49485,7 +49576,7 @@ type MachineNVLinkStatusObservation struct { func (x *MachineNVLinkStatusObservation) Reset() { *x = MachineNVLinkStatusObservation{} - mi := &file_nico_nico_proto_msgTypes[682] + mi := &file_nico_nico_proto_msgTypes[684] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49497,7 +49588,7 @@ func (x *MachineNVLinkStatusObservation) String() string { func (*MachineNVLinkStatusObservation) ProtoMessage() {} func (x *MachineNVLinkStatusObservation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[682] + mi := &file_nico_nico_proto_msgTypes[684] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49510,7 +49601,7 @@ func (x *MachineNVLinkStatusObservation) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineNVLinkStatusObservation.ProtoReflect.Descriptor instead. func (*MachineNVLinkStatusObservation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{682} + return file_nico_nico_proto_rawDescGZIP(), []int{684} } func (x *MachineNVLinkStatusObservation) GetGpuStatus() []*MachineNVLinkGpuStatusObservation { @@ -49534,7 +49625,7 @@ type MachineNVLinkGpuStatusObservation struct { func (x *MachineNVLinkGpuStatusObservation) Reset() { *x = MachineNVLinkGpuStatusObservation{} - mi := &file_nico_nico_proto_msgTypes[683] + mi := &file_nico_nico_proto_msgTypes[685] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49546,7 +49637,7 @@ func (x *MachineNVLinkGpuStatusObservation) String() string { func (*MachineNVLinkGpuStatusObservation) ProtoMessage() {} func (x *MachineNVLinkGpuStatusObservation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[683] + mi := &file_nico_nico_proto_msgTypes[685] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49559,7 +49650,7 @@ func (x *MachineNVLinkGpuStatusObservation) ProtoReflect() protoreflect.Message // Deprecated: Use MachineNVLinkGpuStatusObservation.ProtoReflect.Descriptor instead. func (*MachineNVLinkGpuStatusObservation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{683} + return file_nico_nico_proto_rawDescGZIP(), []int{685} } func (x *MachineNVLinkGpuStatusObservation) GetGpuId() string { @@ -49617,7 +49708,7 @@ type NmxcBrowseRequest struct { func (x *NmxcBrowseRequest) Reset() { *x = NmxcBrowseRequest{} - mi := &file_nico_nico_proto_msgTypes[684] + mi := &file_nico_nico_proto_msgTypes[686] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49629,7 +49720,7 @@ func (x *NmxcBrowseRequest) String() string { func (*NmxcBrowseRequest) ProtoMessage() {} func (x *NmxcBrowseRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[684] + mi := &file_nico_nico_proto_msgTypes[686] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49642,7 +49733,7 @@ func (x *NmxcBrowseRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use NmxcBrowseRequest.ProtoReflect.Descriptor instead. func (*NmxcBrowseRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{684} + return file_nico_nico_proto_rawDescGZIP(), []int{686} } func (x *NmxcBrowseRequest) GetChassisSerial() string { @@ -49680,7 +49771,7 @@ type NmxcBrowseResponse struct { func (x *NmxcBrowseResponse) Reset() { *x = NmxcBrowseResponse{} - mi := &file_nico_nico_proto_msgTypes[685] + mi := &file_nico_nico_proto_msgTypes[687] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49692,7 +49783,7 @@ func (x *NmxcBrowseResponse) String() string { func (*NmxcBrowseResponse) ProtoMessage() {} func (x *NmxcBrowseResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[685] + mi := &file_nico_nico_proto_msgTypes[687] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49705,7 +49796,7 @@ func (x *NmxcBrowseResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use NmxcBrowseResponse.ProtoReflect.Descriptor instead. func (*NmxcBrowseResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{685} + return file_nico_nico_proto_rawDescGZIP(), []int{687} } func (x *NmxcBrowseResponse) GetBody() string { @@ -49743,7 +49834,7 @@ type NVLinkPartition struct { func (x *NVLinkPartition) Reset() { *x = NVLinkPartition{} - mi := &file_nico_nico_proto_msgTypes[686] + mi := &file_nico_nico_proto_msgTypes[688] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49755,7 +49846,7 @@ func (x *NVLinkPartition) String() string { func (*NVLinkPartition) ProtoMessage() {} func (x *NVLinkPartition) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[686] + mi := &file_nico_nico_proto_msgTypes[688] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49768,7 +49859,7 @@ func (x *NVLinkPartition) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartition.ProtoReflect.Descriptor instead. func (*NVLinkPartition) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{686} + return file_nico_nico_proto_rawDescGZIP(), []int{688} } func (x *NVLinkPartition) GetId() *NVLinkPartitionId { @@ -49815,7 +49906,7 @@ type NVLinkPartitionList struct { func (x *NVLinkPartitionList) Reset() { *x = NVLinkPartitionList{} - mi := &file_nico_nico_proto_msgTypes[687] + mi := &file_nico_nico_proto_msgTypes[689] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49827,7 +49918,7 @@ func (x *NVLinkPartitionList) String() string { func (*NVLinkPartitionList) ProtoMessage() {} func (x *NVLinkPartitionList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[687] + mi := &file_nico_nico_proto_msgTypes[689] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49840,7 +49931,7 @@ func (x *NVLinkPartitionList) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartitionList.ProtoReflect.Descriptor instead. func (*NVLinkPartitionList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{687} + return file_nico_nico_proto_rawDescGZIP(), []int{689} } func (x *NVLinkPartitionList) GetPartitions() []*NVLinkPartition { @@ -49859,7 +49950,7 @@ type NVLinkPartitionSearchConfig struct { func (x *NVLinkPartitionSearchConfig) Reset() { *x = NVLinkPartitionSearchConfig{} - mi := &file_nico_nico_proto_msgTypes[688] + mi := &file_nico_nico_proto_msgTypes[690] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49871,7 +49962,7 @@ func (x *NVLinkPartitionSearchConfig) String() string { func (*NVLinkPartitionSearchConfig) ProtoMessage() {} func (x *NVLinkPartitionSearchConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[688] + mi := &file_nico_nico_proto_msgTypes[690] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49884,7 +49975,7 @@ func (x *NVLinkPartitionSearchConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartitionSearchConfig.ProtoReflect.Descriptor instead. func (*NVLinkPartitionSearchConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{688} + return file_nico_nico_proto_rawDescGZIP(), []int{690} } func (x *NVLinkPartitionSearchConfig) GetIncludeHistory() bool { @@ -49904,7 +49995,7 @@ type NVLinkPartitionQuery struct { func (x *NVLinkPartitionQuery) Reset() { *x = NVLinkPartitionQuery{} - mi := &file_nico_nico_proto_msgTypes[689] + mi := &file_nico_nico_proto_msgTypes[691] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49916,7 +50007,7 @@ func (x *NVLinkPartitionQuery) String() string { func (*NVLinkPartitionQuery) ProtoMessage() {} func (x *NVLinkPartitionQuery) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[689] + mi := &file_nico_nico_proto_msgTypes[691] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49929,7 +50020,7 @@ func (x *NVLinkPartitionQuery) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartitionQuery.ProtoReflect.Descriptor instead. func (*NVLinkPartitionQuery) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{689} + return file_nico_nico_proto_rawDescGZIP(), []int{691} } func (x *NVLinkPartitionQuery) GetId() *UUID { @@ -49956,7 +50047,7 @@ type NVLinkPartitionSearchFilter struct { func (x *NVLinkPartitionSearchFilter) Reset() { *x = NVLinkPartitionSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[690] + mi := &file_nico_nico_proto_msgTypes[692] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -49968,7 +50059,7 @@ func (x *NVLinkPartitionSearchFilter) String() string { func (*NVLinkPartitionSearchFilter) ProtoMessage() {} func (x *NVLinkPartitionSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[690] + mi := &file_nico_nico_proto_msgTypes[692] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -49981,7 +50072,7 @@ func (x *NVLinkPartitionSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartitionSearchFilter.ProtoReflect.Descriptor instead. func (*NVLinkPartitionSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{690} + return file_nico_nico_proto_rawDescGZIP(), []int{692} } func (x *NVLinkPartitionSearchFilter) GetTenantOrganizationId() string { @@ -50008,7 +50099,7 @@ type NVLinkPartitionsByIdsRequest struct { func (x *NVLinkPartitionsByIdsRequest) Reset() { *x = NVLinkPartitionsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[691] + mi := &file_nico_nico_proto_msgTypes[693] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50020,7 +50111,7 @@ func (x *NVLinkPartitionsByIdsRequest) String() string { func (*NVLinkPartitionsByIdsRequest) ProtoMessage() {} func (x *NVLinkPartitionsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[691] + mi := &file_nico_nico_proto_msgTypes[693] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50033,7 +50124,7 @@ func (x *NVLinkPartitionsByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartitionsByIdsRequest.ProtoReflect.Descriptor instead. func (*NVLinkPartitionsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{691} + return file_nico_nico_proto_rawDescGZIP(), []int{693} } func (x *NVLinkPartitionsByIdsRequest) GetPartitionIds() []*NVLinkPartitionId { @@ -50059,7 +50150,7 @@ type NVLinkPartitionIdList struct { func (x *NVLinkPartitionIdList) Reset() { *x = NVLinkPartitionIdList{} - mi := &file_nico_nico_proto_msgTypes[692] + mi := &file_nico_nico_proto_msgTypes[694] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50071,7 +50162,7 @@ func (x *NVLinkPartitionIdList) String() string { func (*NVLinkPartitionIdList) ProtoMessage() {} func (x *NVLinkPartitionIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[692] + mi := &file_nico_nico_proto_msgTypes[694] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50084,7 +50175,7 @@ func (x *NVLinkPartitionIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkPartitionIdList.ProtoReflect.Descriptor instead. func (*NVLinkPartitionIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{692} + return file_nico_nico_proto_rawDescGZIP(), []int{694} } func (x *NVLinkPartitionIdList) GetPartitionIds() []*NVLinkPartitionId { @@ -50102,7 +50193,7 @@ type NVLinkFabricSearchFilter struct { func (x *NVLinkFabricSearchFilter) Reset() { *x = NVLinkFabricSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[693] + mi := &file_nico_nico_proto_msgTypes[695] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50114,7 +50205,7 @@ func (x *NVLinkFabricSearchFilter) String() string { func (*NVLinkFabricSearchFilter) ProtoMessage() {} func (x *NVLinkFabricSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[693] + mi := &file_nico_nico_proto_msgTypes[695] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50127,7 +50218,7 @@ func (x *NVLinkFabricSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkFabricSearchFilter.ProtoReflect.Descriptor instead. func (*NVLinkFabricSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{693} + return file_nico_nico_proto_rawDescGZIP(), []int{695} } // Describe the desired configuration of an Logical Partition @@ -50142,7 +50233,7 @@ type NVLinkLogicalPartitionConfig struct { func (x *NVLinkLogicalPartitionConfig) Reset() { *x = NVLinkLogicalPartitionConfig{} - mi := &file_nico_nico_proto_msgTypes[694] + mi := &file_nico_nico_proto_msgTypes[696] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50154,7 +50245,7 @@ func (x *NVLinkLogicalPartitionConfig) String() string { func (*NVLinkLogicalPartitionConfig) ProtoMessage() {} func (x *NVLinkLogicalPartitionConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[694] + mi := &file_nico_nico_proto_msgTypes[696] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50167,7 +50258,7 @@ func (x *NVLinkLogicalPartitionConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkLogicalPartitionConfig.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{694} + return file_nico_nico_proto_rawDescGZIP(), []int{696} } func (x *NVLinkLogicalPartitionConfig) GetMetadata() *Metadata { @@ -50195,7 +50286,7 @@ type NVLinkLogicalPartitionStatus struct { func (x *NVLinkLogicalPartitionStatus) Reset() { *x = NVLinkLogicalPartitionStatus{} - mi := &file_nico_nico_proto_msgTypes[695] + mi := &file_nico_nico_proto_msgTypes[697] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50207,7 +50298,7 @@ func (x *NVLinkLogicalPartitionStatus) String() string { func (*NVLinkLogicalPartitionStatus) ProtoMessage() {} func (x *NVLinkLogicalPartitionStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[695] + mi := &file_nico_nico_proto_msgTypes[697] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50220,7 +50311,7 @@ func (x *NVLinkLogicalPartitionStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkLogicalPartitionStatus.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{695} + return file_nico_nico_proto_rawDescGZIP(), []int{697} } func (x *NVLinkLogicalPartitionStatus) GetState() TenantState { @@ -50244,7 +50335,7 @@ type NVLinkLogicalPartition struct { func (x *NVLinkLogicalPartition) Reset() { *x = NVLinkLogicalPartition{} - mi := &file_nico_nico_proto_msgTypes[696] + mi := &file_nico_nico_proto_msgTypes[698] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50256,7 +50347,7 @@ func (x *NVLinkLogicalPartition) String() string { func (*NVLinkLogicalPartition) ProtoMessage() {} func (x *NVLinkLogicalPartition) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[696] + mi := &file_nico_nico_proto_msgTypes[698] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50269,7 +50360,7 @@ func (x *NVLinkLogicalPartition) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkLogicalPartition.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartition) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{696} + return file_nico_nico_proto_rawDescGZIP(), []int{698} } func (x *NVLinkLogicalPartition) GetId() *NVLinkLogicalPartitionId { @@ -50316,7 +50407,7 @@ type NVLinkLogicalPartitionList struct { func (x *NVLinkLogicalPartitionList) Reset() { *x = NVLinkLogicalPartitionList{} - mi := &file_nico_nico_proto_msgTypes[697] + mi := &file_nico_nico_proto_msgTypes[699] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50328,7 +50419,7 @@ func (x *NVLinkLogicalPartitionList) String() string { func (*NVLinkLogicalPartitionList) ProtoMessage() {} func (x *NVLinkLogicalPartitionList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[697] + mi := &file_nico_nico_proto_msgTypes[699] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50341,7 +50432,7 @@ func (x *NVLinkLogicalPartitionList) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkLogicalPartitionList.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{697} + return file_nico_nico_proto_rawDescGZIP(), []int{699} } func (x *NVLinkLogicalPartitionList) GetPartitions() []*NVLinkLogicalPartition { @@ -50364,7 +50455,7 @@ type NVLinkLogicalPartitionCreationRequest struct { func (x *NVLinkLogicalPartitionCreationRequest) Reset() { *x = NVLinkLogicalPartitionCreationRequest{} - mi := &file_nico_nico_proto_msgTypes[698] + mi := &file_nico_nico_proto_msgTypes[700] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50376,7 +50467,7 @@ func (x *NVLinkLogicalPartitionCreationRequest) String() string { func (*NVLinkLogicalPartitionCreationRequest) ProtoMessage() {} func (x *NVLinkLogicalPartitionCreationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[698] + mi := &file_nico_nico_proto_msgTypes[700] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50389,7 +50480,7 @@ func (x *NVLinkLogicalPartitionCreationRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use NVLinkLogicalPartitionCreationRequest.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionCreationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{698} + return file_nico_nico_proto_rawDescGZIP(), []int{700} } func (x *NVLinkLogicalPartitionCreationRequest) GetConfig() *NVLinkLogicalPartitionConfig { @@ -50415,7 +50506,7 @@ type NVLinkLogicalPartitionDeletionRequest struct { func (x *NVLinkLogicalPartitionDeletionRequest) Reset() { *x = NVLinkLogicalPartitionDeletionRequest{} - mi := &file_nico_nico_proto_msgTypes[699] + mi := &file_nico_nico_proto_msgTypes[701] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50427,7 +50518,7 @@ func (x *NVLinkLogicalPartitionDeletionRequest) String() string { func (*NVLinkLogicalPartitionDeletionRequest) ProtoMessage() {} func (x *NVLinkLogicalPartitionDeletionRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[699] + mi := &file_nico_nico_proto_msgTypes[701] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50440,7 +50531,7 @@ func (x *NVLinkLogicalPartitionDeletionRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use NVLinkLogicalPartitionDeletionRequest.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionDeletionRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{699} + return file_nico_nico_proto_rawDescGZIP(), []int{701} } func (x *NVLinkLogicalPartitionDeletionRequest) GetId() *NVLinkLogicalPartitionId { @@ -50458,7 +50549,7 @@ type NVLinkLogicalPartitionDeletionResult struct { func (x *NVLinkLogicalPartitionDeletionResult) Reset() { *x = NVLinkLogicalPartitionDeletionResult{} - mi := &file_nico_nico_proto_msgTypes[700] + mi := &file_nico_nico_proto_msgTypes[702] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50470,7 +50561,7 @@ func (x *NVLinkLogicalPartitionDeletionResult) String() string { func (*NVLinkLogicalPartitionDeletionResult) ProtoMessage() {} func (x *NVLinkLogicalPartitionDeletionResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[700] + mi := &file_nico_nico_proto_msgTypes[702] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50483,7 +50574,7 @@ func (x *NVLinkLogicalPartitionDeletionResult) ProtoReflect() protoreflect.Messa // Deprecated: Use NVLinkLogicalPartitionDeletionResult.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionDeletionResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{700} + return file_nico_nico_proto_rawDescGZIP(), []int{702} } type NVLinkLogicalPartitionSearchFilter struct { @@ -50495,7 +50586,7 @@ type NVLinkLogicalPartitionSearchFilter struct { func (x *NVLinkLogicalPartitionSearchFilter) Reset() { *x = NVLinkLogicalPartitionSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[701] + mi := &file_nico_nico_proto_msgTypes[703] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50507,7 +50598,7 @@ func (x *NVLinkLogicalPartitionSearchFilter) String() string { func (*NVLinkLogicalPartitionSearchFilter) ProtoMessage() {} func (x *NVLinkLogicalPartitionSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[701] + mi := &file_nico_nico_proto_msgTypes[703] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50520,7 +50611,7 @@ func (x *NVLinkLogicalPartitionSearchFilter) ProtoReflect() protoreflect.Message // Deprecated: Use NVLinkLogicalPartitionSearchFilter.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{701} + return file_nico_nico_proto_rawDescGZIP(), []int{703} } func (x *NVLinkLogicalPartitionSearchFilter) GetName() string { @@ -50540,7 +50631,7 @@ type NVLinkLogicalPartitionsByIdsRequest struct { func (x *NVLinkLogicalPartitionsByIdsRequest) Reset() { *x = NVLinkLogicalPartitionsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[702] + mi := &file_nico_nico_proto_msgTypes[704] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50552,7 +50643,7 @@ func (x *NVLinkLogicalPartitionsByIdsRequest) String() string { func (*NVLinkLogicalPartitionsByIdsRequest) ProtoMessage() {} func (x *NVLinkLogicalPartitionsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[702] + mi := &file_nico_nico_proto_msgTypes[704] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50565,7 +50656,7 @@ func (x *NVLinkLogicalPartitionsByIdsRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use NVLinkLogicalPartitionsByIdsRequest.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{702} + return file_nico_nico_proto_rawDescGZIP(), []int{704} } func (x *NVLinkLogicalPartitionsByIdsRequest) GetPartitionIds() []*NVLinkLogicalPartitionId { @@ -50591,7 +50682,7 @@ type NVLinkLogicalPartitionIdList struct { func (x *NVLinkLogicalPartitionIdList) Reset() { *x = NVLinkLogicalPartitionIdList{} - mi := &file_nico_nico_proto_msgTypes[703] + mi := &file_nico_nico_proto_msgTypes[705] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50603,7 +50694,7 @@ func (x *NVLinkLogicalPartitionIdList) String() string { func (*NVLinkLogicalPartitionIdList) ProtoMessage() {} func (x *NVLinkLogicalPartitionIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[703] + mi := &file_nico_nico_proto_msgTypes[705] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50616,7 +50707,7 @@ func (x *NVLinkLogicalPartitionIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use NVLinkLogicalPartitionIdList.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{703} + return file_nico_nico_proto_rawDescGZIP(), []int{705} } func (x *NVLinkLogicalPartitionIdList) GetPartitionIds() []*NVLinkLogicalPartitionId { @@ -50637,7 +50728,7 @@ type NVLinkLogicalPartitionUpdateRequest struct { func (x *NVLinkLogicalPartitionUpdateRequest) Reset() { *x = NVLinkLogicalPartitionUpdateRequest{} - mi := &file_nico_nico_proto_msgTypes[704] + mi := &file_nico_nico_proto_msgTypes[706] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50649,7 +50740,7 @@ func (x *NVLinkLogicalPartitionUpdateRequest) String() string { func (*NVLinkLogicalPartitionUpdateRequest) ProtoMessage() {} func (x *NVLinkLogicalPartitionUpdateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[704] + mi := &file_nico_nico_proto_msgTypes[706] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50662,7 +50753,7 @@ func (x *NVLinkLogicalPartitionUpdateRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use NVLinkLogicalPartitionUpdateRequest.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionUpdateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{704} + return file_nico_nico_proto_rawDescGZIP(), []int{706} } func (x *NVLinkLogicalPartitionUpdateRequest) GetId() *NVLinkLogicalPartitionId { @@ -50694,7 +50785,7 @@ type NVLinkLogicalPartitionUpdateResult struct { func (x *NVLinkLogicalPartitionUpdateResult) Reset() { *x = NVLinkLogicalPartitionUpdateResult{} - mi := &file_nico_nico_proto_msgTypes[705] + mi := &file_nico_nico_proto_msgTypes[707] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50706,7 +50797,7 @@ func (x *NVLinkLogicalPartitionUpdateResult) String() string { func (*NVLinkLogicalPartitionUpdateResult) ProtoMessage() {} func (x *NVLinkLogicalPartitionUpdateResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[705] + mi := &file_nico_nico_proto_msgTypes[707] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50719,7 +50810,7 @@ func (x *NVLinkLogicalPartitionUpdateResult) ProtoReflect() protoreflect.Message // Deprecated: Use NVLinkLogicalPartitionUpdateResult.ProtoReflect.Descriptor instead. func (*NVLinkLogicalPartitionUpdateResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{705} + return file_nico_nico_proto_rawDescGZIP(), []int{707} } // Must provide either machine_id or ip/mac pair @@ -50736,7 +50827,7 @@ type CreateBmcUserRequest struct { func (x *CreateBmcUserRequest) Reset() { *x = CreateBmcUserRequest{} - mi := &file_nico_nico_proto_msgTypes[706] + mi := &file_nico_nico_proto_msgTypes[708] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50748,7 +50839,7 @@ func (x *CreateBmcUserRequest) String() string { func (*CreateBmcUserRequest) ProtoMessage() {} func (x *CreateBmcUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[706] + mi := &file_nico_nico_proto_msgTypes[708] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50761,7 +50852,7 @@ func (x *CreateBmcUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateBmcUserRequest.ProtoReflect.Descriptor instead. func (*CreateBmcUserRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{706} + return file_nico_nico_proto_rawDescGZIP(), []int{708} } func (x *CreateBmcUserRequest) GetBmcEndpointRequest() *BmcEndpointRequest { @@ -50807,7 +50898,7 @@ type CreateBmcUserResponse struct { func (x *CreateBmcUserResponse) Reset() { *x = CreateBmcUserResponse{} - mi := &file_nico_nico_proto_msgTypes[707] + mi := &file_nico_nico_proto_msgTypes[709] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50819,7 +50910,7 @@ func (x *CreateBmcUserResponse) String() string { func (*CreateBmcUserResponse) ProtoMessage() {} func (x *CreateBmcUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[707] + mi := &file_nico_nico_proto_msgTypes[709] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50832,7 +50923,7 @@ func (x *CreateBmcUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateBmcUserResponse.ProtoReflect.Descriptor instead. func (*CreateBmcUserResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{707} + return file_nico_nico_proto_rawDescGZIP(), []int{709} } type DeleteBmcUserRequest struct { @@ -50846,7 +50937,7 @@ type DeleteBmcUserRequest struct { func (x *DeleteBmcUserRequest) Reset() { *x = DeleteBmcUserRequest{} - mi := &file_nico_nico_proto_msgTypes[708] + mi := &file_nico_nico_proto_msgTypes[710] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50858,7 +50949,7 @@ func (x *DeleteBmcUserRequest) String() string { func (*DeleteBmcUserRequest) ProtoMessage() {} func (x *DeleteBmcUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[708] + mi := &file_nico_nico_proto_msgTypes[710] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50871,7 +50962,7 @@ func (x *DeleteBmcUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteBmcUserRequest.ProtoReflect.Descriptor instead. func (*DeleteBmcUserRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{708} + return file_nico_nico_proto_rawDescGZIP(), []int{710} } func (x *DeleteBmcUserRequest) GetBmcEndpointRequest() *BmcEndpointRequest { @@ -50903,7 +50994,7 @@ type DeleteBmcUserResponse struct { func (x *DeleteBmcUserResponse) Reset() { *x = DeleteBmcUserResponse{} - mi := &file_nico_nico_proto_msgTypes[709] + mi := &file_nico_nico_proto_msgTypes[711] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50915,7 +51006,7 @@ func (x *DeleteBmcUserResponse) String() string { func (*DeleteBmcUserResponse) ProtoMessage() {} func (x *DeleteBmcUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[709] + mi := &file_nico_nico_proto_msgTypes[711] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50928,7 +51019,7 @@ func (x *DeleteBmcUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteBmcUserResponse.ProtoReflect.Descriptor instead. func (*DeleteBmcUserResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{709} + return file_nico_nico_proto_rawDescGZIP(), []int{711} } // Must provide either machine_id or ip/mac pair @@ -50946,7 +51037,7 @@ type SetBmcRootPasswordRequest struct { func (x *SetBmcRootPasswordRequest) Reset() { *x = SetBmcRootPasswordRequest{} - mi := &file_nico_nico_proto_msgTypes[710] + mi := &file_nico_nico_proto_msgTypes[712] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -50958,7 +51049,7 @@ func (x *SetBmcRootPasswordRequest) String() string { func (*SetBmcRootPasswordRequest) ProtoMessage() {} func (x *SetBmcRootPasswordRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[710] + mi := &file_nico_nico_proto_msgTypes[712] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -50971,7 +51062,7 @@ func (x *SetBmcRootPasswordRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetBmcRootPasswordRequest.ProtoReflect.Descriptor instead. func (*SetBmcRootPasswordRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{710} + return file_nico_nico_proto_rawDescGZIP(), []int{712} } func (x *SetBmcRootPasswordRequest) GetBmcEndpointRequest() *BmcEndpointRequest { @@ -51003,7 +51094,7 @@ type SetBmcRootPasswordResponse struct { func (x *SetBmcRootPasswordResponse) Reset() { *x = SetBmcRootPasswordResponse{} - mi := &file_nico_nico_proto_msgTypes[711] + mi := &file_nico_nico_proto_msgTypes[713] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51015,7 +51106,7 @@ func (x *SetBmcRootPasswordResponse) String() string { func (*SetBmcRootPasswordResponse) ProtoMessage() {} func (x *SetBmcRootPasswordResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[711] + mi := &file_nico_nico_proto_msgTypes[713] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51028,7 +51119,7 @@ func (x *SetBmcRootPasswordResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SetBmcRootPasswordResponse.ProtoReflect.Descriptor instead. func (*SetBmcRootPasswordResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{711} + return file_nico_nico_proto_rawDescGZIP(), []int{713} } // Must provide either machine_id or ip/mac pair @@ -51042,7 +51133,7 @@ type ProbeBmcVendorRequest struct { func (x *ProbeBmcVendorRequest) Reset() { *x = ProbeBmcVendorRequest{} - mi := &file_nico_nico_proto_msgTypes[712] + mi := &file_nico_nico_proto_msgTypes[714] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51054,7 +51145,7 @@ func (x *ProbeBmcVendorRequest) String() string { func (*ProbeBmcVendorRequest) ProtoMessage() {} func (x *ProbeBmcVendorRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[712] + mi := &file_nico_nico_proto_msgTypes[714] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51067,7 +51158,7 @@ func (x *ProbeBmcVendorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ProbeBmcVendorRequest.ProtoReflect.Descriptor instead. func (*ProbeBmcVendorRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{712} + return file_nico_nico_proto_rawDescGZIP(), []int{714} } func (x *ProbeBmcVendorRequest) GetBmcEndpointRequest() *BmcEndpointRequest { @@ -51094,7 +51185,7 @@ type ProbeBmcVendorResponse struct { func (x *ProbeBmcVendorResponse) Reset() { *x = ProbeBmcVendorResponse{} - mi := &file_nico_nico_proto_msgTypes[713] + mi := &file_nico_nico_proto_msgTypes[715] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51106,7 +51197,7 @@ func (x *ProbeBmcVendorResponse) String() string { func (*ProbeBmcVendorResponse) ProtoMessage() {} func (x *ProbeBmcVendorResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[713] + mi := &file_nico_nico_proto_msgTypes[715] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51119,7 +51210,7 @@ func (x *ProbeBmcVendorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProbeBmcVendorResponse.ProtoReflect.Descriptor instead. func (*ProbeBmcVendorResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{713} + return file_nico_nico_proto_rawDescGZIP(), []int{715} } func (x *ProbeBmcVendorResponse) GetVendor() string { @@ -51140,7 +51231,7 @@ type SetFirmwareUpdateTimeWindowRequest struct { func (x *SetFirmwareUpdateTimeWindowRequest) Reset() { *x = SetFirmwareUpdateTimeWindowRequest{} - mi := &file_nico_nico_proto_msgTypes[714] + mi := &file_nico_nico_proto_msgTypes[716] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51152,7 +51243,7 @@ func (x *SetFirmwareUpdateTimeWindowRequest) String() string { func (*SetFirmwareUpdateTimeWindowRequest) ProtoMessage() {} func (x *SetFirmwareUpdateTimeWindowRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[714] + mi := &file_nico_nico_proto_msgTypes[716] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51165,7 +51256,7 @@ func (x *SetFirmwareUpdateTimeWindowRequest) ProtoReflect() protoreflect.Message // Deprecated: Use SetFirmwareUpdateTimeWindowRequest.ProtoReflect.Descriptor instead. func (*SetFirmwareUpdateTimeWindowRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{714} + return file_nico_nico_proto_rawDescGZIP(), []int{716} } func (x *SetFirmwareUpdateTimeWindowRequest) GetMachineIds() []*MachineId { @@ -51197,7 +51288,7 @@ type SetFirmwareUpdateTimeWindowResponse struct { func (x *SetFirmwareUpdateTimeWindowResponse) Reset() { *x = SetFirmwareUpdateTimeWindowResponse{} - mi := &file_nico_nico_proto_msgTypes[715] + mi := &file_nico_nico_proto_msgTypes[717] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51209,7 +51300,7 @@ func (x *SetFirmwareUpdateTimeWindowResponse) String() string { func (*SetFirmwareUpdateTimeWindowResponse) ProtoMessage() {} func (x *SetFirmwareUpdateTimeWindowResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[715] + mi := &file_nico_nico_proto_msgTypes[717] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51222,7 +51313,7 @@ func (x *SetFirmwareUpdateTimeWindowResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use SetFirmwareUpdateTimeWindowResponse.ProtoReflect.Descriptor instead. func (*SetFirmwareUpdateTimeWindowResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{715} + return file_nico_nico_proto_rawDescGZIP(), []int{717} } type UpsertHostFirmwareConfigRequest struct { @@ -51238,7 +51329,7 @@ type UpsertHostFirmwareConfigRequest struct { func (x *UpsertHostFirmwareConfigRequest) Reset() { *x = UpsertHostFirmwareConfigRequest{} - mi := &file_nico_nico_proto_msgTypes[716] + mi := &file_nico_nico_proto_msgTypes[718] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51250,7 +51341,7 @@ func (x *UpsertHostFirmwareConfigRequest) String() string { func (*UpsertHostFirmwareConfigRequest) ProtoMessage() {} func (x *UpsertHostFirmwareConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[716] + mi := &file_nico_nico_proto_msgTypes[718] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51263,7 +51354,7 @@ func (x *UpsertHostFirmwareConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpsertHostFirmwareConfigRequest.ProtoReflect.Descriptor instead. func (*UpsertHostFirmwareConfigRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{716} + return file_nico_nico_proto_rawDescGZIP(), []int{718} } func (x *UpsertHostFirmwareConfigRequest) GetVendor() string { @@ -51311,7 +51402,7 @@ type DeleteHostFirmwareConfigRequest struct { func (x *DeleteHostFirmwareConfigRequest) Reset() { *x = DeleteHostFirmwareConfigRequest{} - mi := &file_nico_nico_proto_msgTypes[717] + mi := &file_nico_nico_proto_msgTypes[719] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51323,7 +51414,7 @@ func (x *DeleteHostFirmwareConfigRequest) String() string { func (*DeleteHostFirmwareConfigRequest) ProtoMessage() {} func (x *DeleteHostFirmwareConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[717] + mi := &file_nico_nico_proto_msgTypes[719] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51336,7 +51427,7 @@ func (x *DeleteHostFirmwareConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteHostFirmwareConfigRequest.ProtoReflect.Descriptor instead. func (*DeleteHostFirmwareConfigRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{717} + return file_nico_nico_proto_rawDescGZIP(), []int{719} } func (x *DeleteHostFirmwareConfigRequest) GetVendor() string { @@ -51364,7 +51455,7 @@ type UpsertHostFirmwareComponentConfig struct { func (x *UpsertHostFirmwareComponentConfig) Reset() { *x = UpsertHostFirmwareComponentConfig{} - mi := &file_nico_nico_proto_msgTypes[718] + mi := &file_nico_nico_proto_msgTypes[720] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51376,7 +51467,7 @@ func (x *UpsertHostFirmwareComponentConfig) String() string { func (*UpsertHostFirmwareComponentConfig) ProtoMessage() {} func (x *UpsertHostFirmwareComponentConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[718] + mi := &file_nico_nico_proto_msgTypes[720] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51389,7 +51480,7 @@ func (x *UpsertHostFirmwareComponentConfig) ProtoReflect() protoreflect.Message // Deprecated: Use UpsertHostFirmwareComponentConfig.ProtoReflect.Descriptor instead. func (*UpsertHostFirmwareComponentConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{718} + return file_nico_nico_proto_rawDescGZIP(), []int{720} } func (x *UpsertHostFirmwareComponentConfig) GetType() HostFirmwareComponentType { @@ -51425,7 +51516,7 @@ type HostFirmwareComponentConfigResponse struct { func (x *HostFirmwareComponentConfigResponse) Reset() { *x = HostFirmwareComponentConfigResponse{} - mi := &file_nico_nico_proto_msgTypes[719] + mi := &file_nico_nico_proto_msgTypes[721] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51437,7 +51528,7 @@ func (x *HostFirmwareComponentConfigResponse) String() string { func (*HostFirmwareComponentConfigResponse) ProtoMessage() {} func (x *HostFirmwareComponentConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[719] + mi := &file_nico_nico_proto_msgTypes[721] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51450,7 +51541,7 @@ func (x *HostFirmwareComponentConfigResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use HostFirmwareComponentConfigResponse.ProtoReflect.Descriptor instead. func (*HostFirmwareComponentConfigResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{719} + return file_nico_nico_proto_rawDescGZIP(), []int{721} } func (x *HostFirmwareComponentConfigResponse) GetType() HostFirmwareComponentType { @@ -51496,7 +51587,7 @@ type HostFirmwareVersionConfig struct { func (x *HostFirmwareVersionConfig) Reset() { *x = HostFirmwareVersionConfig{} - mi := &file_nico_nico_proto_msgTypes[720] + mi := &file_nico_nico_proto_msgTypes[722] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51508,7 +51599,7 @@ func (x *HostFirmwareVersionConfig) String() string { func (*HostFirmwareVersionConfig) ProtoMessage() {} func (x *HostFirmwareVersionConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[720] + mi := &file_nico_nico_proto_msgTypes[722] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51521,7 +51612,7 @@ func (x *HostFirmwareVersionConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use HostFirmwareVersionConfig.ProtoReflect.Descriptor instead. func (*HostFirmwareVersionConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{720} + return file_nico_nico_proto_rawDescGZIP(), []int{722} } func (x *HostFirmwareVersionConfig) GetVersion() string { @@ -51583,7 +51674,7 @@ type HostFirmwareArtifact struct { func (x *HostFirmwareArtifact) Reset() { *x = HostFirmwareArtifact{} - mi := &file_nico_nico_proto_msgTypes[721] + mi := &file_nico_nico_proto_msgTypes[723] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51595,7 +51686,7 @@ func (x *HostFirmwareArtifact) String() string { func (*HostFirmwareArtifact) ProtoMessage() {} func (x *HostFirmwareArtifact) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[721] + mi := &file_nico_nico_proto_msgTypes[723] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51608,7 +51699,7 @@ func (x *HostFirmwareArtifact) ProtoReflect() protoreflect.Message { // Deprecated: Use HostFirmwareArtifact.ProtoReflect.Descriptor instead. func (*HostFirmwareArtifact) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{721} + return file_nico_nico_proto_rawDescGZIP(), []int{723} } func (x *HostFirmwareArtifact) GetUrl() string { @@ -51640,7 +51731,7 @@ type HostFirmwareConfigResponse struct { func (x *HostFirmwareConfigResponse) Reset() { *x = HostFirmwareConfigResponse{} - mi := &file_nico_nico_proto_msgTypes[722] + mi := &file_nico_nico_proto_msgTypes[724] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51652,7 +51743,7 @@ func (x *HostFirmwareConfigResponse) String() string { func (*HostFirmwareConfigResponse) ProtoMessage() {} func (x *HostFirmwareConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[722] + mi := &file_nico_nico_proto_msgTypes[724] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51665,7 +51756,7 @@ func (x *HostFirmwareConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use HostFirmwareConfigResponse.ProtoReflect.Descriptor instead. func (*HostFirmwareConfigResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{722} + return file_nico_nico_proto_rawDescGZIP(), []int{724} } func (x *HostFirmwareConfigResponse) GetVendor() string { @@ -51725,7 +51816,7 @@ type ListHostFirmwareRequest struct { func (x *ListHostFirmwareRequest) Reset() { *x = ListHostFirmwareRequest{} - mi := &file_nico_nico_proto_msgTypes[723] + mi := &file_nico_nico_proto_msgTypes[725] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51737,7 +51828,7 @@ func (x *ListHostFirmwareRequest) String() string { func (*ListHostFirmwareRequest) ProtoMessage() {} func (x *ListHostFirmwareRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[723] + mi := &file_nico_nico_proto_msgTypes[725] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51750,7 +51841,7 @@ func (x *ListHostFirmwareRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListHostFirmwareRequest.ProtoReflect.Descriptor instead. func (*ListHostFirmwareRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{723} + return file_nico_nico_proto_rawDescGZIP(), []int{725} } type ListHostFirmwareResponse struct { @@ -51762,7 +51853,7 @@ type ListHostFirmwareResponse struct { func (x *ListHostFirmwareResponse) Reset() { *x = ListHostFirmwareResponse{} - mi := &file_nico_nico_proto_msgTypes[724] + mi := &file_nico_nico_proto_msgTypes[726] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51774,7 +51865,7 @@ func (x *ListHostFirmwareResponse) String() string { func (*ListHostFirmwareResponse) ProtoMessage() {} func (x *ListHostFirmwareResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[724] + mi := &file_nico_nico_proto_msgTypes[726] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51787,7 +51878,7 @@ func (x *ListHostFirmwareResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListHostFirmwareResponse.ProtoReflect.Descriptor instead. func (*ListHostFirmwareResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{724} + return file_nico_nico_proto_rawDescGZIP(), []int{726} } func (x *ListHostFirmwareResponse) GetAvailable() []*AvailableHostFirmware { @@ -51811,7 +51902,7 @@ type AvailableHostFirmware struct { func (x *AvailableHostFirmware) Reset() { *x = AvailableHostFirmware{} - mi := &file_nico_nico_proto_msgTypes[725] + mi := &file_nico_nico_proto_msgTypes[727] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51823,7 +51914,7 @@ func (x *AvailableHostFirmware) String() string { func (*AvailableHostFirmware) ProtoMessage() {} func (x *AvailableHostFirmware) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[725] + mi := &file_nico_nico_proto_msgTypes[727] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51836,7 +51927,7 @@ func (x *AvailableHostFirmware) ProtoReflect() protoreflect.Message { // Deprecated: Use AvailableHostFirmware.ProtoReflect.Descriptor instead. func (*AvailableHostFirmware) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{725} + return file_nico_nico_proto_rawDescGZIP(), []int{727} } func (x *AvailableHostFirmware) GetVendor() string { @@ -51891,7 +51982,7 @@ type TrimTableRequest struct { func (x *TrimTableRequest) Reset() { *x = TrimTableRequest{} - mi := &file_nico_nico_proto_msgTypes[726] + mi := &file_nico_nico_proto_msgTypes[728] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51903,7 +51994,7 @@ func (x *TrimTableRequest) String() string { func (*TrimTableRequest) ProtoMessage() {} func (x *TrimTableRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[726] + mi := &file_nico_nico_proto_msgTypes[728] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51916,7 +52007,7 @@ func (x *TrimTableRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use TrimTableRequest.ProtoReflect.Descriptor instead. func (*TrimTableRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{726} + return file_nico_nico_proto_rawDescGZIP(), []int{728} } func (x *TrimTableRequest) GetTarget() TrimTableTarget { @@ -51942,7 +52033,7 @@ type TrimTableResponse struct { func (x *TrimTableResponse) Reset() { *x = TrimTableResponse{} - mi := &file_nico_nico_proto_msgTypes[727] + mi := &file_nico_nico_proto_msgTypes[729] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51954,7 +52045,7 @@ func (x *TrimTableResponse) String() string { func (*TrimTableResponse) ProtoMessage() {} func (x *TrimTableResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[727] + mi := &file_nico_nico_proto_msgTypes[729] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -51967,7 +52058,7 @@ func (x *TrimTableResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use TrimTableResponse.ProtoReflect.Descriptor instead. func (*TrimTableResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{727} + return file_nico_nico_proto_rawDescGZIP(), []int{729} } func (x *TrimTableResponse) GetTotalDeleted() string { @@ -51987,7 +52078,7 @@ type NvlinkNmxcEndpoint struct { func (x *NvlinkNmxcEndpoint) Reset() { *x = NvlinkNmxcEndpoint{} - mi := &file_nico_nico_proto_msgTypes[728] + mi := &file_nico_nico_proto_msgTypes[730] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -51999,7 +52090,7 @@ func (x *NvlinkNmxcEndpoint) String() string { func (*NvlinkNmxcEndpoint) ProtoMessage() {} func (x *NvlinkNmxcEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[728] + mi := &file_nico_nico_proto_msgTypes[730] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52012,7 +52103,7 @@ func (x *NvlinkNmxcEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use NvlinkNmxcEndpoint.ProtoReflect.Descriptor instead. func (*NvlinkNmxcEndpoint) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{728} + return file_nico_nico_proto_rawDescGZIP(), []int{730} } func (x *NvlinkNmxcEndpoint) GetChassisSerial() string { @@ -52038,7 +52129,7 @@ type NvlinkNmxcEndpointList struct { func (x *NvlinkNmxcEndpointList) Reset() { *x = NvlinkNmxcEndpointList{} - mi := &file_nico_nico_proto_msgTypes[729] + mi := &file_nico_nico_proto_msgTypes[731] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52050,7 +52141,7 @@ func (x *NvlinkNmxcEndpointList) String() string { func (*NvlinkNmxcEndpointList) ProtoMessage() {} func (x *NvlinkNmxcEndpointList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[729] + mi := &file_nico_nico_proto_msgTypes[731] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52063,7 +52154,7 @@ func (x *NvlinkNmxcEndpointList) ProtoReflect() protoreflect.Message { // Deprecated: Use NvlinkNmxcEndpointList.ProtoReflect.Descriptor instead. func (*NvlinkNmxcEndpointList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{729} + return file_nico_nico_proto_rawDescGZIP(), []int{731} } func (x *NvlinkNmxcEndpointList) GetEntries() []*NvlinkNmxcEndpoint { @@ -52082,7 +52173,7 @@ type DeleteNvlinkNmxcEndpointRequest struct { func (x *DeleteNvlinkNmxcEndpointRequest) Reset() { *x = DeleteNvlinkNmxcEndpointRequest{} - mi := &file_nico_nico_proto_msgTypes[730] + mi := &file_nico_nico_proto_msgTypes[732] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52094,7 +52185,7 @@ func (x *DeleteNvlinkNmxcEndpointRequest) String() string { func (*DeleteNvlinkNmxcEndpointRequest) ProtoMessage() {} func (x *DeleteNvlinkNmxcEndpointRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[730] + mi := &file_nico_nico_proto_msgTypes[732] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52107,7 +52198,7 @@ func (x *DeleteNvlinkNmxcEndpointRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteNvlinkNmxcEndpointRequest.ProtoReflect.Descriptor instead. func (*DeleteNvlinkNmxcEndpointRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{730} + return file_nico_nico_proto_rawDescGZIP(), []int{732} } func (x *DeleteNvlinkNmxcEndpointRequest) GetChassisSerial() string { @@ -52129,7 +52220,7 @@ type CreateRemediationRequest struct { func (x *CreateRemediationRequest) Reset() { *x = CreateRemediationRequest{} - mi := &file_nico_nico_proto_msgTypes[731] + mi := &file_nico_nico_proto_msgTypes[733] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52141,7 +52232,7 @@ func (x *CreateRemediationRequest) String() string { func (*CreateRemediationRequest) ProtoMessage() {} func (x *CreateRemediationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[731] + mi := &file_nico_nico_proto_msgTypes[733] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52154,7 +52245,7 @@ func (x *CreateRemediationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateRemediationRequest.ProtoReflect.Descriptor instead. func (*CreateRemediationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{731} + return file_nico_nico_proto_rawDescGZIP(), []int{733} } func (x *CreateRemediationRequest) GetScript() string { @@ -52187,7 +52278,7 @@ type CreateRemediationResponse struct { func (x *CreateRemediationResponse) Reset() { *x = CreateRemediationResponse{} - mi := &file_nico_nico_proto_msgTypes[732] + mi := &file_nico_nico_proto_msgTypes[734] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52199,7 +52290,7 @@ func (x *CreateRemediationResponse) String() string { func (*CreateRemediationResponse) ProtoMessage() {} func (x *CreateRemediationResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[732] + mi := &file_nico_nico_proto_msgTypes[734] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52212,7 +52303,7 @@ func (x *CreateRemediationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateRemediationResponse.ProtoReflect.Descriptor instead. func (*CreateRemediationResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{732} + return file_nico_nico_proto_rawDescGZIP(), []int{734} } func (x *CreateRemediationResponse) GetRemediationId() *RemediationId { @@ -52231,7 +52322,7 @@ type RemediationIdList struct { func (x *RemediationIdList) Reset() { *x = RemediationIdList{} - mi := &file_nico_nico_proto_msgTypes[733] + mi := &file_nico_nico_proto_msgTypes[735] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52243,7 +52334,7 @@ func (x *RemediationIdList) String() string { func (*RemediationIdList) ProtoMessage() {} func (x *RemediationIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[733] + mi := &file_nico_nico_proto_msgTypes[735] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52256,7 +52347,7 @@ func (x *RemediationIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use RemediationIdList.ProtoReflect.Descriptor instead. func (*RemediationIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{733} + return file_nico_nico_proto_rawDescGZIP(), []int{735} } func (x *RemediationIdList) GetRemediationIds() []*RemediationId { @@ -52275,7 +52366,7 @@ type RemediationList struct { func (x *RemediationList) Reset() { *x = RemediationList{} - mi := &file_nico_nico_proto_msgTypes[734] + mi := &file_nico_nico_proto_msgTypes[736] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52287,7 +52378,7 @@ func (x *RemediationList) String() string { func (*RemediationList) ProtoMessage() {} func (x *RemediationList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[734] + mi := &file_nico_nico_proto_msgTypes[736] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52300,7 +52391,7 @@ func (x *RemediationList) ProtoReflect() protoreflect.Message { // Deprecated: Use RemediationList.ProtoReflect.Descriptor instead. func (*RemediationList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{734} + return file_nico_nico_proto_rawDescGZIP(), []int{736} } func (x *RemediationList) GetRemediations() []*Remediation { @@ -52326,7 +52417,7 @@ type Remediation struct { func (x *Remediation) Reset() { *x = Remediation{} - mi := &file_nico_nico_proto_msgTypes[735] + mi := &file_nico_nico_proto_msgTypes[737] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52338,7 +52429,7 @@ func (x *Remediation) String() string { func (*Remediation) ProtoMessage() {} func (x *Remediation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[735] + mi := &file_nico_nico_proto_msgTypes[737] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52351,7 +52442,7 @@ func (x *Remediation) ProtoReflect() protoreflect.Message { // Deprecated: Use Remediation.ProtoReflect.Descriptor instead. func (*Remediation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{735} + return file_nico_nico_proto_rawDescGZIP(), []int{737} } func (x *Remediation) GetId() *RemediationId { @@ -52419,7 +52510,7 @@ type ApproveRemediationRequest struct { func (x *ApproveRemediationRequest) Reset() { *x = ApproveRemediationRequest{} - mi := &file_nico_nico_proto_msgTypes[736] + mi := &file_nico_nico_proto_msgTypes[738] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52431,7 +52522,7 @@ func (x *ApproveRemediationRequest) String() string { func (*ApproveRemediationRequest) ProtoMessage() {} func (x *ApproveRemediationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[736] + mi := &file_nico_nico_proto_msgTypes[738] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52444,7 +52535,7 @@ func (x *ApproveRemediationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveRemediationRequest.ProtoReflect.Descriptor instead. func (*ApproveRemediationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{736} + return file_nico_nico_proto_rawDescGZIP(), []int{738} } func (x *ApproveRemediationRequest) GetRemediationId() *RemediationId { @@ -52463,7 +52554,7 @@ type RevokeRemediationRequest struct { func (x *RevokeRemediationRequest) Reset() { *x = RevokeRemediationRequest{} - mi := &file_nico_nico_proto_msgTypes[737] + mi := &file_nico_nico_proto_msgTypes[739] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52475,7 +52566,7 @@ func (x *RevokeRemediationRequest) String() string { func (*RevokeRemediationRequest) ProtoMessage() {} func (x *RevokeRemediationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[737] + mi := &file_nico_nico_proto_msgTypes[739] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52488,7 +52579,7 @@ func (x *RevokeRemediationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeRemediationRequest.ProtoReflect.Descriptor instead. func (*RevokeRemediationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{737} + return file_nico_nico_proto_rawDescGZIP(), []int{739} } func (x *RevokeRemediationRequest) GetRemediationId() *RemediationId { @@ -52507,7 +52598,7 @@ type EnableRemediationRequest struct { func (x *EnableRemediationRequest) Reset() { *x = EnableRemediationRequest{} - mi := &file_nico_nico_proto_msgTypes[738] + mi := &file_nico_nico_proto_msgTypes[740] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52519,7 +52610,7 @@ func (x *EnableRemediationRequest) String() string { func (*EnableRemediationRequest) ProtoMessage() {} func (x *EnableRemediationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[738] + mi := &file_nico_nico_proto_msgTypes[740] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52532,7 +52623,7 @@ func (x *EnableRemediationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EnableRemediationRequest.ProtoReflect.Descriptor instead. func (*EnableRemediationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{738} + return file_nico_nico_proto_rawDescGZIP(), []int{740} } func (x *EnableRemediationRequest) GetRemediationId() *RemediationId { @@ -52551,7 +52642,7 @@ type DisableRemediationRequest struct { func (x *DisableRemediationRequest) Reset() { *x = DisableRemediationRequest{} - mi := &file_nico_nico_proto_msgTypes[739] + mi := &file_nico_nico_proto_msgTypes[741] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52563,7 +52654,7 @@ func (x *DisableRemediationRequest) String() string { func (*DisableRemediationRequest) ProtoMessage() {} func (x *DisableRemediationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[739] + mi := &file_nico_nico_proto_msgTypes[741] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52576,7 +52667,7 @@ func (x *DisableRemediationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DisableRemediationRequest.ProtoReflect.Descriptor instead. func (*DisableRemediationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{739} + return file_nico_nico_proto_rawDescGZIP(), []int{741} } func (x *DisableRemediationRequest) GetRemediationId() *RemediationId { @@ -52598,7 +52689,7 @@ type FindAppliedRemediationIdsRequest struct { func (x *FindAppliedRemediationIdsRequest) Reset() { *x = FindAppliedRemediationIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[740] + mi := &file_nico_nico_proto_msgTypes[742] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52610,7 +52701,7 @@ func (x *FindAppliedRemediationIdsRequest) String() string { func (*FindAppliedRemediationIdsRequest) ProtoMessage() {} func (x *FindAppliedRemediationIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[740] + mi := &file_nico_nico_proto_msgTypes[742] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52623,7 +52714,7 @@ func (x *FindAppliedRemediationIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FindAppliedRemediationIdsRequest.ProtoReflect.Descriptor instead. func (*FindAppliedRemediationIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{740} + return file_nico_nico_proto_rawDescGZIP(), []int{742} } func (x *FindAppliedRemediationIdsRequest) GetRemediationId() *RemediationId { @@ -52650,7 +52741,7 @@ type AppliedRemediationIdList struct { func (x *AppliedRemediationIdList) Reset() { *x = AppliedRemediationIdList{} - mi := &file_nico_nico_proto_msgTypes[741] + mi := &file_nico_nico_proto_msgTypes[743] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52662,7 +52753,7 @@ func (x *AppliedRemediationIdList) String() string { func (*AppliedRemediationIdList) ProtoMessage() {} func (x *AppliedRemediationIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[741] + mi := &file_nico_nico_proto_msgTypes[743] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52675,7 +52766,7 @@ func (x *AppliedRemediationIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use AppliedRemediationIdList.ProtoReflect.Descriptor instead. func (*AppliedRemediationIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{741} + return file_nico_nico_proto_rawDescGZIP(), []int{743} } func (x *AppliedRemediationIdList) GetRemediationIds() []*RemediationId { @@ -52702,7 +52793,7 @@ type FindAppliedRemediationsRequest struct { func (x *FindAppliedRemediationsRequest) Reset() { *x = FindAppliedRemediationsRequest{} - mi := &file_nico_nico_proto_msgTypes[742] + mi := &file_nico_nico_proto_msgTypes[744] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52714,7 +52805,7 @@ func (x *FindAppliedRemediationsRequest) String() string { func (*FindAppliedRemediationsRequest) ProtoMessage() {} func (x *FindAppliedRemediationsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[742] + mi := &file_nico_nico_proto_msgTypes[744] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52727,7 +52818,7 @@ func (x *FindAppliedRemediationsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FindAppliedRemediationsRequest.ProtoReflect.Descriptor instead. func (*FindAppliedRemediationsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{742} + return file_nico_nico_proto_rawDescGZIP(), []int{744} } func (x *FindAppliedRemediationsRequest) GetRemediationId() *RemediationId { @@ -52758,7 +52849,7 @@ type AppliedRemediation struct { func (x *AppliedRemediation) Reset() { *x = AppliedRemediation{} - mi := &file_nico_nico_proto_msgTypes[743] + mi := &file_nico_nico_proto_msgTypes[745] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52770,7 +52861,7 @@ func (x *AppliedRemediation) String() string { func (*AppliedRemediation) ProtoMessage() {} func (x *AppliedRemediation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[743] + mi := &file_nico_nico_proto_msgTypes[745] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52783,7 +52874,7 @@ func (x *AppliedRemediation) ProtoReflect() protoreflect.Message { // Deprecated: Use AppliedRemediation.ProtoReflect.Descriptor instead. func (*AppliedRemediation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{743} + return file_nico_nico_proto_rawDescGZIP(), []int{745} } func (x *AppliedRemediation) GetRemediationId() *RemediationId { @@ -52837,7 +52928,7 @@ type AppliedRemediationList struct { func (x *AppliedRemediationList) Reset() { *x = AppliedRemediationList{} - mi := &file_nico_nico_proto_msgTypes[744] + mi := &file_nico_nico_proto_msgTypes[746] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52849,7 +52940,7 @@ func (x *AppliedRemediationList) String() string { func (*AppliedRemediationList) ProtoMessage() {} func (x *AppliedRemediationList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[744] + mi := &file_nico_nico_proto_msgTypes[746] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52862,7 +52953,7 @@ func (x *AppliedRemediationList) ProtoReflect() protoreflect.Message { // Deprecated: Use AppliedRemediationList.ProtoReflect.Descriptor instead. func (*AppliedRemediationList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{744} + return file_nico_nico_proto_rawDescGZIP(), []int{746} } func (x *AppliedRemediationList) GetAppliedRemediations() []*AppliedRemediation { @@ -52881,7 +52972,7 @@ type GetNextRemediationForMachineRequest struct { func (x *GetNextRemediationForMachineRequest) Reset() { *x = GetNextRemediationForMachineRequest{} - mi := &file_nico_nico_proto_msgTypes[745] + mi := &file_nico_nico_proto_msgTypes[747] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52893,7 +52984,7 @@ func (x *GetNextRemediationForMachineRequest) String() string { func (*GetNextRemediationForMachineRequest) ProtoMessage() {} func (x *GetNextRemediationForMachineRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[745] + mi := &file_nico_nico_proto_msgTypes[747] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52906,7 +52997,7 @@ func (x *GetNextRemediationForMachineRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use GetNextRemediationForMachineRequest.ProtoReflect.Descriptor instead. func (*GetNextRemediationForMachineRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{745} + return file_nico_nico_proto_rawDescGZIP(), []int{747} } func (x *GetNextRemediationForMachineRequest) GetDpuMachineId() *MachineId { @@ -52926,7 +53017,7 @@ type GetNextRemediationForMachineResponse struct { func (x *GetNextRemediationForMachineResponse) Reset() { *x = GetNextRemediationForMachineResponse{} - mi := &file_nico_nico_proto_msgTypes[746] + mi := &file_nico_nico_proto_msgTypes[748] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52938,7 +53029,7 @@ func (x *GetNextRemediationForMachineResponse) String() string { func (*GetNextRemediationForMachineResponse) ProtoMessage() {} func (x *GetNextRemediationForMachineResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[746] + mi := &file_nico_nico_proto_msgTypes[748] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -52951,7 +53042,7 @@ func (x *GetNextRemediationForMachineResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use GetNextRemediationForMachineResponse.ProtoReflect.Descriptor instead. func (*GetNextRemediationForMachineResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{746} + return file_nico_nico_proto_rawDescGZIP(), []int{748} } func (x *GetNextRemediationForMachineResponse) GetRemediationId() *RemediationId { @@ -52979,7 +53070,7 @@ type RemediationAppliedRequest struct { func (x *RemediationAppliedRequest) Reset() { *x = RemediationAppliedRequest{} - mi := &file_nico_nico_proto_msgTypes[747] + mi := &file_nico_nico_proto_msgTypes[749] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52991,7 +53082,7 @@ func (x *RemediationAppliedRequest) String() string { func (*RemediationAppliedRequest) ProtoMessage() {} func (x *RemediationAppliedRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[747] + mi := &file_nico_nico_proto_msgTypes[749] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53004,7 +53095,7 @@ func (x *RemediationAppliedRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemediationAppliedRequest.ProtoReflect.Descriptor instead. func (*RemediationAppliedRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{747} + return file_nico_nico_proto_rawDescGZIP(), []int{749} } func (x *RemediationAppliedRequest) GetRemediationId() *RemediationId { @@ -53038,7 +53129,7 @@ type RemediationApplicationStatus struct { func (x *RemediationApplicationStatus) Reset() { *x = RemediationApplicationStatus{} - mi := &file_nico_nico_proto_msgTypes[748] + mi := &file_nico_nico_proto_msgTypes[750] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53050,7 +53141,7 @@ func (x *RemediationApplicationStatus) String() string { func (*RemediationApplicationStatus) ProtoMessage() {} func (x *RemediationApplicationStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[748] + mi := &file_nico_nico_proto_msgTypes[750] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53063,7 +53154,7 @@ func (x *RemediationApplicationStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use RemediationApplicationStatus.ProtoReflect.Descriptor instead. func (*RemediationApplicationStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{748} + return file_nico_nico_proto_rawDescGZIP(), []int{750} } func (x *RemediationApplicationStatus) GetSucceeded() bool { @@ -53097,7 +53188,7 @@ type SetPrimaryDpuRequest struct { func (x *SetPrimaryDpuRequest) Reset() { *x = SetPrimaryDpuRequest{} - mi := &file_nico_nico_proto_msgTypes[749] + mi := &file_nico_nico_proto_msgTypes[751] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53109,7 +53200,7 @@ func (x *SetPrimaryDpuRequest) String() string { func (*SetPrimaryDpuRequest) ProtoMessage() {} func (x *SetPrimaryDpuRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[749] + mi := &file_nico_nico_proto_msgTypes[751] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53122,7 +53213,7 @@ func (x *SetPrimaryDpuRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetPrimaryDpuRequest.ProtoReflect.Descriptor instead. func (*SetPrimaryDpuRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{749} + return file_nico_nico_proto_rawDescGZIP(), []int{751} } func (x *SetPrimaryDpuRequest) GetHostMachineId() *MachineId { @@ -53171,7 +53262,7 @@ type SetPrimaryInterfaceRequest struct { func (x *SetPrimaryInterfaceRequest) Reset() { *x = SetPrimaryInterfaceRequest{} - mi := &file_nico_nico_proto_msgTypes[750] + mi := &file_nico_nico_proto_msgTypes[752] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53183,7 +53274,7 @@ func (x *SetPrimaryInterfaceRequest) String() string { func (*SetPrimaryInterfaceRequest) ProtoMessage() {} func (x *SetPrimaryInterfaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[750] + mi := &file_nico_nico_proto_msgTypes[752] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53196,7 +53287,7 @@ func (x *SetPrimaryInterfaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetPrimaryInterfaceRequest.ProtoReflect.Descriptor instead. func (*SetPrimaryInterfaceRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{750} + return file_nico_nico_proto_rawDescGZIP(), []int{752} } func (x *SetPrimaryInterfaceRequest) GetHostMachineId() *MachineId { @@ -53238,7 +53329,7 @@ type UsernamePassword struct { func (x *UsernamePassword) Reset() { *x = UsernamePassword{} - mi := &file_nico_nico_proto_msgTypes[751] + mi := &file_nico_nico_proto_msgTypes[753] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53250,7 +53341,7 @@ func (x *UsernamePassword) String() string { func (*UsernamePassword) ProtoMessage() {} func (x *UsernamePassword) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[751] + mi := &file_nico_nico_proto_msgTypes[753] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53263,7 +53354,7 @@ func (x *UsernamePassword) ProtoReflect() protoreflect.Message { // Deprecated: Use UsernamePassword.ProtoReflect.Descriptor instead. func (*UsernamePassword) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{751} + return file_nico_nico_proto_rawDescGZIP(), []int{753} } func (x *UsernamePassword) GetUsername() string { @@ -53289,7 +53380,7 @@ type SessionToken struct { func (x *SessionToken) Reset() { *x = SessionToken{} - mi := &file_nico_nico_proto_msgTypes[752] + mi := &file_nico_nico_proto_msgTypes[754] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53301,7 +53392,7 @@ func (x *SessionToken) String() string { func (*SessionToken) ProtoMessage() {} func (x *SessionToken) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[752] + mi := &file_nico_nico_proto_msgTypes[754] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53314,7 +53405,7 @@ func (x *SessionToken) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionToken.ProtoReflect.Descriptor instead. func (*SessionToken) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{752} + return file_nico_nico_proto_rawDescGZIP(), []int{754} } func (x *SessionToken) GetToken() string { @@ -53337,7 +53428,7 @@ type DpuExtensionServiceCredential struct { func (x *DpuExtensionServiceCredential) Reset() { *x = DpuExtensionServiceCredential{} - mi := &file_nico_nico_proto_msgTypes[753] + mi := &file_nico_nico_proto_msgTypes[755] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53349,7 +53440,7 @@ func (x *DpuExtensionServiceCredential) String() string { func (*DpuExtensionServiceCredential) ProtoMessage() {} func (x *DpuExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[753] + mi := &file_nico_nico_proto_msgTypes[755] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53362,7 +53453,7 @@ func (x *DpuExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{753} + return file_nico_nico_proto_rawDescGZIP(), []int{755} } func (x *DpuExtensionServiceCredential) GetRegistryUrl() string { @@ -53411,7 +53502,7 @@ type DpuExtensionServiceVersionInfo struct { func (x *DpuExtensionServiceVersionInfo) Reset() { *x = DpuExtensionServiceVersionInfo{} - mi := &file_nico_nico_proto_msgTypes[754] + mi := &file_nico_nico_proto_msgTypes[756] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53423,7 +53514,7 @@ func (x *DpuExtensionServiceVersionInfo) String() string { func (*DpuExtensionServiceVersionInfo) ProtoMessage() {} func (x *DpuExtensionServiceVersionInfo) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[754] + mi := &file_nico_nico_proto_msgTypes[756] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53436,7 +53527,7 @@ func (x *DpuExtensionServiceVersionInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServiceVersionInfo.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceVersionInfo) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{754} + return file_nico_nico_proto_rawDescGZIP(), []int{756} } func (x *DpuExtensionServiceVersionInfo) GetVersion() string { @@ -53497,7 +53588,7 @@ type DpuExtensionService struct { func (x *DpuExtensionService) Reset() { *x = DpuExtensionService{} - mi := &file_nico_nico_proto_msgTypes[755] + mi := &file_nico_nico_proto_msgTypes[757] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53509,7 +53600,7 @@ func (x *DpuExtensionService) String() string { func (*DpuExtensionService) ProtoMessage() {} func (x *DpuExtensionService) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[755] + mi := &file_nico_nico_proto_msgTypes[757] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53522,7 +53613,7 @@ func (x *DpuExtensionService) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionService.ProtoReflect.Descriptor instead. func (*DpuExtensionService) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{755} + return file_nico_nico_proto_rawDescGZIP(), []int{757} } func (x *DpuExtensionService) GetServiceId() string { @@ -53615,7 +53706,7 @@ type CreateDpuExtensionServiceRequest struct { func (x *CreateDpuExtensionServiceRequest) Reset() { *x = CreateDpuExtensionServiceRequest{} - mi := &file_nico_nico_proto_msgTypes[756] + mi := &file_nico_nico_proto_msgTypes[758] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53627,7 +53718,7 @@ func (x *CreateDpuExtensionServiceRequest) String() string { func (*CreateDpuExtensionServiceRequest) ProtoMessage() {} func (x *CreateDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[756] + mi := &file_nico_nico_proto_msgTypes[758] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53640,7 +53731,7 @@ func (x *CreateDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateDpuExtensionServiceRequest.ProtoReflect.Descriptor instead. func (*CreateDpuExtensionServiceRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{756} + return file_nico_nico_proto_rawDescGZIP(), []int{758} } func (x *CreateDpuExtensionServiceRequest) GetServiceId() string { @@ -53722,7 +53813,7 @@ type UpdateDpuExtensionServiceRequest struct { func (x *UpdateDpuExtensionServiceRequest) Reset() { *x = UpdateDpuExtensionServiceRequest{} - mi := &file_nico_nico_proto_msgTypes[757] + mi := &file_nico_nico_proto_msgTypes[759] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53734,7 +53825,7 @@ func (x *UpdateDpuExtensionServiceRequest) String() string { func (*UpdateDpuExtensionServiceRequest) ProtoMessage() {} func (x *UpdateDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[757] + mi := &file_nico_nico_proto_msgTypes[759] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53747,7 +53838,7 @@ func (x *UpdateDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateDpuExtensionServiceRequest.ProtoReflect.Descriptor instead. func (*UpdateDpuExtensionServiceRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{757} + return file_nico_nico_proto_rawDescGZIP(), []int{759} } func (x *UpdateDpuExtensionServiceRequest) GetServiceId() string { @@ -53812,7 +53903,7 @@ type DeleteDpuExtensionServiceRequest struct { func (x *DeleteDpuExtensionServiceRequest) Reset() { *x = DeleteDpuExtensionServiceRequest{} - mi := &file_nico_nico_proto_msgTypes[758] + mi := &file_nico_nico_proto_msgTypes[760] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53824,7 +53915,7 @@ func (x *DeleteDpuExtensionServiceRequest) String() string { func (*DeleteDpuExtensionServiceRequest) ProtoMessage() {} func (x *DeleteDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[758] + mi := &file_nico_nico_proto_msgTypes[760] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53837,7 +53928,7 @@ func (x *DeleteDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteDpuExtensionServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteDpuExtensionServiceRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{758} + return file_nico_nico_proto_rawDescGZIP(), []int{760} } func (x *DeleteDpuExtensionServiceRequest) GetServiceId() string { @@ -53862,7 +53953,7 @@ type DeleteDpuExtensionServiceResponse struct { func (x *DeleteDpuExtensionServiceResponse) Reset() { *x = DeleteDpuExtensionServiceResponse{} - mi := &file_nico_nico_proto_msgTypes[759] + mi := &file_nico_nico_proto_msgTypes[761] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53874,7 +53965,7 @@ func (x *DeleteDpuExtensionServiceResponse) String() string { func (*DeleteDpuExtensionServiceResponse) ProtoMessage() {} func (x *DeleteDpuExtensionServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[759] + mi := &file_nico_nico_proto_msgTypes[761] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53887,7 +53978,7 @@ func (x *DeleteDpuExtensionServiceResponse) ProtoReflect() protoreflect.Message // Deprecated: Use DeleteDpuExtensionServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteDpuExtensionServiceResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{759} + return file_nico_nico_proto_rawDescGZIP(), []int{761} } type DpuExtensionServiceSearchFilter struct { @@ -53901,7 +53992,7 @@ type DpuExtensionServiceSearchFilter struct { func (x *DpuExtensionServiceSearchFilter) Reset() { *x = DpuExtensionServiceSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[760] + mi := &file_nico_nico_proto_msgTypes[762] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53913,7 +54004,7 @@ func (x *DpuExtensionServiceSearchFilter) String() string { func (*DpuExtensionServiceSearchFilter) ProtoMessage() {} func (x *DpuExtensionServiceSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[760] + mi := &file_nico_nico_proto_msgTypes[762] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53926,7 +54017,7 @@ func (x *DpuExtensionServiceSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServiceSearchFilter.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{760} + return file_nico_nico_proto_rawDescGZIP(), []int{762} } func (x *DpuExtensionServiceSearchFilter) GetServiceType() DpuExtensionServiceType { @@ -53959,7 +54050,7 @@ type DpuExtensionServiceIdList struct { func (x *DpuExtensionServiceIdList) Reset() { *x = DpuExtensionServiceIdList{} - mi := &file_nico_nico_proto_msgTypes[761] + mi := &file_nico_nico_proto_msgTypes[763] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -53971,7 +54062,7 @@ func (x *DpuExtensionServiceIdList) String() string { func (*DpuExtensionServiceIdList) ProtoMessage() {} func (x *DpuExtensionServiceIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[761] + mi := &file_nico_nico_proto_msgTypes[763] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -53984,7 +54075,7 @@ func (x *DpuExtensionServiceIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServiceIdList.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{761} + return file_nico_nico_proto_rawDescGZIP(), []int{763} } func (x *DpuExtensionServiceIdList) GetServiceIds() []string { @@ -54003,7 +54094,7 @@ type DpuExtensionServicesByIdsRequest struct { func (x *DpuExtensionServicesByIdsRequest) Reset() { *x = DpuExtensionServicesByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[762] + mi := &file_nico_nico_proto_msgTypes[764] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54015,7 +54106,7 @@ func (x *DpuExtensionServicesByIdsRequest) String() string { func (*DpuExtensionServicesByIdsRequest) ProtoMessage() {} func (x *DpuExtensionServicesByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[762] + mi := &file_nico_nico_proto_msgTypes[764] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54028,7 +54119,7 @@ func (x *DpuExtensionServicesByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServicesByIdsRequest.ProtoReflect.Descriptor instead. func (*DpuExtensionServicesByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{762} + return file_nico_nico_proto_rawDescGZIP(), []int{764} } func (x *DpuExtensionServicesByIdsRequest) GetServiceIds() []string { @@ -54047,7 +54138,7 @@ type DpuExtensionServiceList struct { func (x *DpuExtensionServiceList) Reset() { *x = DpuExtensionServiceList{} - mi := &file_nico_nico_proto_msgTypes[763] + mi := &file_nico_nico_proto_msgTypes[765] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54059,7 +54150,7 @@ func (x *DpuExtensionServiceList) String() string { func (*DpuExtensionServiceList) ProtoMessage() {} func (x *DpuExtensionServiceList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[763] + mi := &file_nico_nico_proto_msgTypes[765] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54072,7 +54163,7 @@ func (x *DpuExtensionServiceList) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServiceList.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{763} + return file_nico_nico_proto_rawDescGZIP(), []int{765} } func (x *DpuExtensionServiceList) GetServices() []*DpuExtensionService { @@ -54093,7 +54184,7 @@ type GetDpuExtensionServiceVersionsInfoRequest struct { func (x *GetDpuExtensionServiceVersionsInfoRequest) Reset() { *x = GetDpuExtensionServiceVersionsInfoRequest{} - mi := &file_nico_nico_proto_msgTypes[764] + mi := &file_nico_nico_proto_msgTypes[766] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54105,7 +54196,7 @@ func (x *GetDpuExtensionServiceVersionsInfoRequest) String() string { func (*GetDpuExtensionServiceVersionsInfoRequest) ProtoMessage() {} func (x *GetDpuExtensionServiceVersionsInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[764] + mi := &file_nico_nico_proto_msgTypes[766] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54118,7 +54209,7 @@ func (x *GetDpuExtensionServiceVersionsInfoRequest) ProtoReflect() protoreflect. // Deprecated: Use GetDpuExtensionServiceVersionsInfoRequest.ProtoReflect.Descriptor instead. func (*GetDpuExtensionServiceVersionsInfoRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{764} + return file_nico_nico_proto_rawDescGZIP(), []int{766} } func (x *GetDpuExtensionServiceVersionsInfoRequest) GetServiceId() string { @@ -54144,7 +54235,7 @@ type DpuExtensionServiceVersionInfoList struct { func (x *DpuExtensionServiceVersionInfoList) Reset() { *x = DpuExtensionServiceVersionInfoList{} - mi := &file_nico_nico_proto_msgTypes[765] + mi := &file_nico_nico_proto_msgTypes[767] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54156,7 +54247,7 @@ func (x *DpuExtensionServiceVersionInfoList) String() string { func (*DpuExtensionServiceVersionInfoList) ProtoMessage() {} func (x *DpuExtensionServiceVersionInfoList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[765] + mi := &file_nico_nico_proto_msgTypes[767] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54169,7 +54260,7 @@ func (x *DpuExtensionServiceVersionInfoList) ProtoReflect() protoreflect.Message // Deprecated: Use DpuExtensionServiceVersionInfoList.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceVersionInfoList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{765} + return file_nico_nico_proto_rawDescGZIP(), []int{767} } func (x *DpuExtensionServiceVersionInfoList) GetVersionInfos() []*DpuExtensionServiceVersionInfo { @@ -54189,7 +54280,7 @@ type FindInstancesByDpuExtensionServiceRequest struct { func (x *FindInstancesByDpuExtensionServiceRequest) Reset() { *x = FindInstancesByDpuExtensionServiceRequest{} - mi := &file_nico_nico_proto_msgTypes[766] + mi := &file_nico_nico_proto_msgTypes[768] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54201,7 +54292,7 @@ func (x *FindInstancesByDpuExtensionServiceRequest) String() string { func (*FindInstancesByDpuExtensionServiceRequest) ProtoMessage() {} func (x *FindInstancesByDpuExtensionServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[766] + mi := &file_nico_nico_proto_msgTypes[768] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54214,7 +54305,7 @@ func (x *FindInstancesByDpuExtensionServiceRequest) ProtoReflect() protoreflect. // Deprecated: Use FindInstancesByDpuExtensionServiceRequest.ProtoReflect.Descriptor instead. func (*FindInstancesByDpuExtensionServiceRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{766} + return file_nico_nico_proto_rawDescGZIP(), []int{768} } func (x *FindInstancesByDpuExtensionServiceRequest) GetServiceId() string { @@ -54240,7 +54331,7 @@ type FindInstancesByDpuExtensionServiceResponse struct { func (x *FindInstancesByDpuExtensionServiceResponse) Reset() { *x = FindInstancesByDpuExtensionServiceResponse{} - mi := &file_nico_nico_proto_msgTypes[767] + mi := &file_nico_nico_proto_msgTypes[769] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54252,7 +54343,7 @@ func (x *FindInstancesByDpuExtensionServiceResponse) String() string { func (*FindInstancesByDpuExtensionServiceResponse) ProtoMessage() {} func (x *FindInstancesByDpuExtensionServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[767] + mi := &file_nico_nico_proto_msgTypes[769] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54265,7 +54356,7 @@ func (x *FindInstancesByDpuExtensionServiceResponse) ProtoReflect() protoreflect // Deprecated: Use FindInstancesByDpuExtensionServiceResponse.ProtoReflect.Descriptor instead. func (*FindInstancesByDpuExtensionServiceResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{767} + return file_nico_nico_proto_rawDescGZIP(), []int{769} } func (x *FindInstancesByDpuExtensionServiceResponse) GetInstances() []*InstanceDpuExtensionServiceInfo { @@ -54287,7 +54378,7 @@ type InstanceDpuExtensionServiceInfo struct { func (x *InstanceDpuExtensionServiceInfo) Reset() { *x = InstanceDpuExtensionServiceInfo{} - mi := &file_nico_nico_proto_msgTypes[768] + mi := &file_nico_nico_proto_msgTypes[770] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54299,7 +54390,7 @@ func (x *InstanceDpuExtensionServiceInfo) String() string { func (*InstanceDpuExtensionServiceInfo) ProtoMessage() {} func (x *InstanceDpuExtensionServiceInfo) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[768] + mi := &file_nico_nico_proto_msgTypes[770] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54312,7 +54403,7 @@ func (x *InstanceDpuExtensionServiceInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use InstanceDpuExtensionServiceInfo.ProtoReflect.Descriptor instead. func (*InstanceDpuExtensionServiceInfo) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{768} + return file_nico_nico_proto_rawDescGZIP(), []int{770} } func (x *InstanceDpuExtensionServiceInfo) GetInstanceId() string { @@ -54353,7 +54444,7 @@ type DpuExtensionServiceObservabilityConfigPrometheus struct { func (x *DpuExtensionServiceObservabilityConfigPrometheus) Reset() { *x = DpuExtensionServiceObservabilityConfigPrometheus{} - mi := &file_nico_nico_proto_msgTypes[769] + mi := &file_nico_nico_proto_msgTypes[771] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54365,7 +54456,7 @@ func (x *DpuExtensionServiceObservabilityConfigPrometheus) String() string { func (*DpuExtensionServiceObservabilityConfigPrometheus) ProtoMessage() {} func (x *DpuExtensionServiceObservabilityConfigPrometheus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[769] + mi := &file_nico_nico_proto_msgTypes[771] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54378,7 +54469,7 @@ func (x *DpuExtensionServiceObservabilityConfigPrometheus) ProtoReflect() protor // Deprecated: Use DpuExtensionServiceObservabilityConfigPrometheus.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceObservabilityConfigPrometheus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{769} + return file_nico_nico_proto_rawDescGZIP(), []int{771} } func (x *DpuExtensionServiceObservabilityConfigPrometheus) GetScrapeIntervalSeconds() uint32 { @@ -54404,7 +54495,7 @@ type DpuExtensionServiceObservabilityConfigLogging struct { func (x *DpuExtensionServiceObservabilityConfigLogging) Reset() { *x = DpuExtensionServiceObservabilityConfigLogging{} - mi := &file_nico_nico_proto_msgTypes[770] + mi := &file_nico_nico_proto_msgTypes[772] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54416,7 +54507,7 @@ func (x *DpuExtensionServiceObservabilityConfigLogging) String() string { func (*DpuExtensionServiceObservabilityConfigLogging) ProtoMessage() {} func (x *DpuExtensionServiceObservabilityConfigLogging) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[770] + mi := &file_nico_nico_proto_msgTypes[772] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54429,7 +54520,7 @@ func (x *DpuExtensionServiceObservabilityConfigLogging) ProtoReflect() protorefl // Deprecated: Use DpuExtensionServiceObservabilityConfigLogging.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceObservabilityConfigLogging) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{770} + return file_nico_nico_proto_rawDescGZIP(), []int{772} } func (x *DpuExtensionServiceObservabilityConfigLogging) GetPath() string { @@ -54456,7 +54547,7 @@ type DpuExtensionServiceObservabilityConfig struct { func (x *DpuExtensionServiceObservabilityConfig) Reset() { *x = DpuExtensionServiceObservabilityConfig{} - mi := &file_nico_nico_proto_msgTypes[771] + mi := &file_nico_nico_proto_msgTypes[773] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54468,7 +54559,7 @@ func (x *DpuExtensionServiceObservabilityConfig) String() string { func (*DpuExtensionServiceObservabilityConfig) ProtoMessage() {} func (x *DpuExtensionServiceObservabilityConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[771] + mi := &file_nico_nico_proto_msgTypes[773] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54481,7 +54572,7 @@ func (x *DpuExtensionServiceObservabilityConfig) ProtoReflect() protoreflect.Mes // Deprecated: Use DpuExtensionServiceObservabilityConfig.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceObservabilityConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{771} + return file_nico_nico_proto_rawDescGZIP(), []int{773} } func (x *DpuExtensionServiceObservabilityConfig) GetName() string { @@ -54543,7 +54634,7 @@ type DpuExtensionServiceObservability struct { func (x *DpuExtensionServiceObservability) Reset() { *x = DpuExtensionServiceObservability{} - mi := &file_nico_nico_proto_msgTypes[772] + mi := &file_nico_nico_proto_msgTypes[774] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54555,7 +54646,7 @@ func (x *DpuExtensionServiceObservability) String() string { func (*DpuExtensionServiceObservability) ProtoMessage() {} func (x *DpuExtensionServiceObservability) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[772] + mi := &file_nico_nico_proto_msgTypes[774] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54568,7 +54659,7 @@ func (x *DpuExtensionServiceObservability) ProtoReflect() protoreflect.Message { // Deprecated: Use DpuExtensionServiceObservability.ProtoReflect.Descriptor instead. func (*DpuExtensionServiceObservability) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{772} + return file_nico_nico_proto_rawDescGZIP(), []int{774} } func (x *DpuExtensionServiceObservability) GetConfigs() []*DpuExtensionServiceObservabilityConfig { @@ -54613,7 +54704,7 @@ type ScoutStreamApiBoundMessage struct { func (x *ScoutStreamApiBoundMessage) Reset() { *x = ScoutStreamApiBoundMessage{} - mi := &file_nico_nico_proto_msgTypes[773] + mi := &file_nico_nico_proto_msgTypes[775] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54625,7 +54716,7 @@ func (x *ScoutStreamApiBoundMessage) String() string { func (*ScoutStreamApiBoundMessage) ProtoMessage() {} func (x *ScoutStreamApiBoundMessage) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[773] + mi := &file_nico_nico_proto_msgTypes[775] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54638,7 +54729,7 @@ func (x *ScoutStreamApiBoundMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamApiBoundMessage.ProtoReflect.Descriptor instead. func (*ScoutStreamApiBoundMessage) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{773} + return file_nico_nico_proto_rawDescGZIP(), []int{775} } func (x *ScoutStreamApiBoundMessage) GetFlowUuid() *UUID { @@ -54908,7 +54999,7 @@ type ScoutStreamScoutBoundMessage struct { func (x *ScoutStreamScoutBoundMessage) Reset() { *x = ScoutStreamScoutBoundMessage{} - mi := &file_nico_nico_proto_msgTypes[774] + mi := &file_nico_nico_proto_msgTypes[776] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -54920,7 +55011,7 @@ func (x *ScoutStreamScoutBoundMessage) String() string { func (*ScoutStreamScoutBoundMessage) ProtoMessage() {} func (x *ScoutStreamScoutBoundMessage) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[774] + mi := &file_nico_nico_proto_msgTypes[776] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -54933,7 +55024,7 @@ func (x *ScoutStreamScoutBoundMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamScoutBoundMessage.ProtoReflect.Descriptor instead. func (*ScoutStreamScoutBoundMessage) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{774} + return file_nico_nico_proto_rawDescGZIP(), []int{776} } func (x *ScoutStreamScoutBoundMessage) GetFlowUuid() *UUID { @@ -55189,7 +55280,7 @@ type ScoutStreamInitRequest struct { func (x *ScoutStreamInitRequest) Reset() { *x = ScoutStreamInitRequest{} - mi := &file_nico_nico_proto_msgTypes[775] + mi := &file_nico_nico_proto_msgTypes[777] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55201,7 +55292,7 @@ func (x *ScoutStreamInitRequest) String() string { func (*ScoutStreamInitRequest) ProtoMessage() {} func (x *ScoutStreamInitRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[775] + mi := &file_nico_nico_proto_msgTypes[777] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55214,7 +55305,7 @@ func (x *ScoutStreamInitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamInitRequest.ProtoReflect.Descriptor instead. func (*ScoutStreamInitRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{775} + return file_nico_nico_proto_rawDescGZIP(), []int{777} } func (x *ScoutStreamInitRequest) GetMachineId() *MachineId { @@ -55234,7 +55325,7 @@ type ScoutStreamShowConnectionsRequest struct { func (x *ScoutStreamShowConnectionsRequest) Reset() { *x = ScoutStreamShowConnectionsRequest{} - mi := &file_nico_nico_proto_msgTypes[776] + mi := &file_nico_nico_proto_msgTypes[778] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55246,7 +55337,7 @@ func (x *ScoutStreamShowConnectionsRequest) String() string { func (*ScoutStreamShowConnectionsRequest) ProtoMessage() {} func (x *ScoutStreamShowConnectionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[776] + mi := &file_nico_nico_proto_msgTypes[778] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55259,7 +55350,7 @@ func (x *ScoutStreamShowConnectionsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ScoutStreamShowConnectionsRequest.ProtoReflect.Descriptor instead. func (*ScoutStreamShowConnectionsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{776} + return file_nico_nico_proto_rawDescGZIP(), []int{778} } // ShowConnectionsResponse is the response containing active @@ -55273,7 +55364,7 @@ type ScoutStreamShowConnectionsResponse struct { func (x *ScoutStreamShowConnectionsResponse) Reset() { *x = ScoutStreamShowConnectionsResponse{} - mi := &file_nico_nico_proto_msgTypes[777] + mi := &file_nico_nico_proto_msgTypes[779] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55285,7 +55376,7 @@ func (x *ScoutStreamShowConnectionsResponse) String() string { func (*ScoutStreamShowConnectionsResponse) ProtoMessage() {} func (x *ScoutStreamShowConnectionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[777] + mi := &file_nico_nico_proto_msgTypes[779] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55298,7 +55389,7 @@ func (x *ScoutStreamShowConnectionsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ScoutStreamShowConnectionsResponse.ProtoReflect.Descriptor instead. func (*ScoutStreamShowConnectionsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{777} + return file_nico_nico_proto_rawDescGZIP(), []int{779} } func (x *ScoutStreamShowConnectionsResponse) GetScoutStreamConnections() []*ScoutStreamConnectionInfo { @@ -55319,7 +55410,7 @@ type ScoutStreamDisconnectRequest struct { func (x *ScoutStreamDisconnectRequest) Reset() { *x = ScoutStreamDisconnectRequest{} - mi := &file_nico_nico_proto_msgTypes[778] + mi := &file_nico_nico_proto_msgTypes[780] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55331,7 +55422,7 @@ func (x *ScoutStreamDisconnectRequest) String() string { func (*ScoutStreamDisconnectRequest) ProtoMessage() {} func (x *ScoutStreamDisconnectRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[778] + mi := &file_nico_nico_proto_msgTypes[780] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55344,7 +55435,7 @@ func (x *ScoutStreamDisconnectRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamDisconnectRequest.ProtoReflect.Descriptor instead. func (*ScoutStreamDisconnectRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{778} + return file_nico_nico_proto_rawDescGZIP(), []int{780} } func (x *ScoutStreamDisconnectRequest) GetMachineId() *MachineId { @@ -55366,7 +55457,7 @@ type ScoutStreamDisconnectResponse struct { func (x *ScoutStreamDisconnectResponse) Reset() { *x = ScoutStreamDisconnectResponse{} - mi := &file_nico_nico_proto_msgTypes[779] + mi := &file_nico_nico_proto_msgTypes[781] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55378,7 +55469,7 @@ func (x *ScoutStreamDisconnectResponse) String() string { func (*ScoutStreamDisconnectResponse) ProtoMessage() {} func (x *ScoutStreamDisconnectResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[779] + mi := &file_nico_nico_proto_msgTypes[781] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55391,7 +55482,7 @@ func (x *ScoutStreamDisconnectResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamDisconnectResponse.ProtoReflect.Descriptor instead. func (*ScoutStreamDisconnectResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{779} + return file_nico_nico_proto_rawDescGZIP(), []int{781} } func (x *ScoutStreamDisconnectResponse) GetMachineId() *MachineId { @@ -55420,7 +55511,7 @@ type ScoutStreamAdminPingRequest struct { func (x *ScoutStreamAdminPingRequest) Reset() { *x = ScoutStreamAdminPingRequest{} - mi := &file_nico_nico_proto_msgTypes[780] + mi := &file_nico_nico_proto_msgTypes[782] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55432,7 +55523,7 @@ func (x *ScoutStreamAdminPingRequest) String() string { func (*ScoutStreamAdminPingRequest) ProtoMessage() {} func (x *ScoutStreamAdminPingRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[780] + mi := &file_nico_nico_proto_msgTypes[782] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55445,7 +55536,7 @@ func (x *ScoutStreamAdminPingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamAdminPingRequest.ProtoReflect.Descriptor instead. func (*ScoutStreamAdminPingRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{780} + return file_nico_nico_proto_rawDescGZIP(), []int{782} } func (x *ScoutStreamAdminPingRequest) GetMachineId() *MachineId { @@ -55466,7 +55557,7 @@ type ScoutStreamAdminPingResponse struct { func (x *ScoutStreamAdminPingResponse) Reset() { *x = ScoutStreamAdminPingResponse{} - mi := &file_nico_nico_proto_msgTypes[781] + mi := &file_nico_nico_proto_msgTypes[783] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55478,7 +55569,7 @@ func (x *ScoutStreamAdminPingResponse) String() string { func (*ScoutStreamAdminPingResponse) ProtoMessage() {} func (x *ScoutStreamAdminPingResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[781] + mi := &file_nico_nico_proto_msgTypes[783] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55491,7 +55582,7 @@ func (x *ScoutStreamAdminPingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamAdminPingResponse.ProtoReflect.Descriptor instead. func (*ScoutStreamAdminPingResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{781} + return file_nico_nico_proto_rawDescGZIP(), []int{783} } func (x *ScoutStreamAdminPingResponse) GetPong() string { @@ -55512,7 +55603,7 @@ type ScoutStreamAgentPingRequest struct { func (x *ScoutStreamAgentPingRequest) Reset() { *x = ScoutStreamAgentPingRequest{} - mi := &file_nico_nico_proto_msgTypes[782] + mi := &file_nico_nico_proto_msgTypes[784] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55524,7 +55615,7 @@ func (x *ScoutStreamAgentPingRequest) String() string { func (*ScoutStreamAgentPingRequest) ProtoMessage() {} func (x *ScoutStreamAgentPingRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[782] + mi := &file_nico_nico_proto_msgTypes[784] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55537,7 +55628,7 @@ func (x *ScoutStreamAgentPingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamAgentPingRequest.ProtoReflect.Descriptor instead. func (*ScoutStreamAgentPingRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{782} + return file_nico_nico_proto_rawDescGZIP(), []int{784} } // ScoutStreamAgentPingResponse is hopefully a response from @@ -55555,7 +55646,7 @@ type ScoutStreamAgentPingResponse struct { func (x *ScoutStreamAgentPingResponse) Reset() { *x = ScoutStreamAgentPingResponse{} - mi := &file_nico_nico_proto_msgTypes[783] + mi := &file_nico_nico_proto_msgTypes[785] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55567,7 +55658,7 @@ func (x *ScoutStreamAgentPingResponse) String() string { func (*ScoutStreamAgentPingResponse) ProtoMessage() {} func (x *ScoutStreamAgentPingResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[783] + mi := &file_nico_nico_proto_msgTypes[785] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55580,7 +55671,7 @@ func (x *ScoutStreamAgentPingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamAgentPingResponse.ProtoReflect.Descriptor instead. func (*ScoutStreamAgentPingResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{783} + return file_nico_nico_proto_rawDescGZIP(), []int{785} } func (x *ScoutStreamAgentPingResponse) GetReply() isScoutStreamAgentPingResponse_Reply { @@ -55641,7 +55732,7 @@ type ScoutStreamConnectionInfo struct { func (x *ScoutStreamConnectionInfo) Reset() { *x = ScoutStreamConnectionInfo{} - mi := &file_nico_nico_proto_msgTypes[784] + mi := &file_nico_nico_proto_msgTypes[786] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55653,7 +55744,7 @@ func (x *ScoutStreamConnectionInfo) String() string { func (*ScoutStreamConnectionInfo) ProtoMessage() {} func (x *ScoutStreamConnectionInfo) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[784] + mi := &file_nico_nico_proto_msgTypes[786] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55666,7 +55757,7 @@ func (x *ScoutStreamConnectionInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamConnectionInfo.ProtoReflect.Descriptor instead. func (*ScoutStreamConnectionInfo) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{784} + return file_nico_nico_proto_rawDescGZIP(), []int{786} } func (x *ScoutStreamConnectionInfo) GetMachineId() *MachineId { @@ -55703,7 +55794,7 @@ type ScoutStreamError struct { func (x *ScoutStreamError) Reset() { *x = ScoutStreamError{} - mi := &file_nico_nico_proto_msgTypes[785] + mi := &file_nico_nico_proto_msgTypes[787] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55715,7 +55806,7 @@ func (x *ScoutStreamError) String() string { func (*ScoutStreamError) ProtoMessage() {} func (x *ScoutStreamError) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[785] + mi := &file_nico_nico_proto_msgTypes[787] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55728,7 +55819,7 @@ func (x *ScoutStreamError) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoutStreamError.ProtoReflect.Descriptor instead. func (*ScoutStreamError) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{785} + return file_nico_nico_proto_rawDescGZIP(), []int{787} } func (x *ScoutStreamError) GetStatus() ScoutStreamErrorStatus { @@ -55758,7 +55849,7 @@ type PrefixFilterPolicyEntry struct { func (x *PrefixFilterPolicyEntry) Reset() { *x = PrefixFilterPolicyEntry{} - mi := &file_nico_nico_proto_msgTypes[786] + mi := &file_nico_nico_proto_msgTypes[788] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55770,7 +55861,7 @@ func (x *PrefixFilterPolicyEntry) String() string { func (*PrefixFilterPolicyEntry) ProtoMessage() {} func (x *PrefixFilterPolicyEntry) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[786] + mi := &file_nico_nico_proto_msgTypes[788] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55783,7 +55874,7 @@ func (x *PrefixFilterPolicyEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use PrefixFilterPolicyEntry.ProtoReflect.Descriptor instead. func (*PrefixFilterPolicyEntry) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{786} + return file_nico_nico_proto_rawDescGZIP(), []int{788} } func (x *PrefixFilterPolicyEntry) GetPrefix() string { @@ -55818,7 +55909,7 @@ type RoutingProfile struct { func (x *RoutingProfile) Reset() { *x = RoutingProfile{} - mi := &file_nico_nico_proto_msgTypes[787] + mi := &file_nico_nico_proto_msgTypes[789] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55830,7 +55921,7 @@ func (x *RoutingProfile) String() string { func (*RoutingProfile) ProtoMessage() {} func (x *RoutingProfile) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[787] + mi := &file_nico_nico_proto_msgTypes[789] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55843,7 +55934,7 @@ func (x *RoutingProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use RoutingProfile.ProtoReflect.Descriptor instead. func (*RoutingProfile) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{787} + return file_nico_nico_proto_rawDescGZIP(), []int{789} } func (x *RoutingProfile) GetRouteTargetImports() []*RouteTarget { @@ -55909,7 +56000,7 @@ type DomainLegacy struct { func (x *DomainLegacy) Reset() { *x = DomainLegacy{} - mi := &file_nico_nico_proto_msgTypes[788] + mi := &file_nico_nico_proto_msgTypes[790] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55921,7 +56012,7 @@ func (x *DomainLegacy) String() string { func (*DomainLegacy) ProtoMessage() {} func (x *DomainLegacy) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[788] + mi := &file_nico_nico_proto_msgTypes[790] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -55934,7 +56025,7 @@ func (x *DomainLegacy) ProtoReflect() protoreflect.Message { // Deprecated: Use DomainLegacy.ProtoReflect.Descriptor instead. func (*DomainLegacy) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{788} + return file_nico_nico_proto_rawDescGZIP(), []int{790} } func (x *DomainLegacy) GetId() *DomainId { @@ -55982,7 +56073,7 @@ type DomainListLegacy struct { func (x *DomainListLegacy) Reset() { *x = DomainListLegacy{} - mi := &file_nico_nico_proto_msgTypes[789] + mi := &file_nico_nico_proto_msgTypes[791] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -55994,7 +56085,7 @@ func (x *DomainListLegacy) String() string { func (*DomainListLegacy) ProtoMessage() {} func (x *DomainListLegacy) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[789] + mi := &file_nico_nico_proto_msgTypes[791] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56007,7 +56098,7 @@ func (x *DomainListLegacy) ProtoReflect() protoreflect.Message { // Deprecated: Use DomainListLegacy.ProtoReflect.Descriptor instead. func (*DomainListLegacy) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{789} + return file_nico_nico_proto_rawDescGZIP(), []int{791} } func (x *DomainListLegacy) GetDomains() []*DomainLegacy { @@ -56027,7 +56118,7 @@ type DomainDeletionLegacy struct { func (x *DomainDeletionLegacy) Reset() { *x = DomainDeletionLegacy{} - mi := &file_nico_nico_proto_msgTypes[790] + mi := &file_nico_nico_proto_msgTypes[792] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56039,7 +56130,7 @@ func (x *DomainDeletionLegacy) String() string { func (*DomainDeletionLegacy) ProtoMessage() {} func (x *DomainDeletionLegacy) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[790] + mi := &file_nico_nico_proto_msgTypes[792] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56052,7 +56143,7 @@ func (x *DomainDeletionLegacy) ProtoReflect() protoreflect.Message { // Deprecated: Use DomainDeletionLegacy.ProtoReflect.Descriptor instead. func (*DomainDeletionLegacy) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{790} + return file_nico_nico_proto_rawDescGZIP(), []int{792} } func (x *DomainDeletionLegacy) GetId() *DomainId { @@ -56071,7 +56162,7 @@ type DomainDeletionResultLegacy struct { func (x *DomainDeletionResultLegacy) Reset() { *x = DomainDeletionResultLegacy{} - mi := &file_nico_nico_proto_msgTypes[791] + mi := &file_nico_nico_proto_msgTypes[793] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56083,7 +56174,7 @@ func (x *DomainDeletionResultLegacy) String() string { func (*DomainDeletionResultLegacy) ProtoMessage() {} func (x *DomainDeletionResultLegacy) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[791] + mi := &file_nico_nico_proto_msgTypes[793] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56096,7 +56187,7 @@ func (x *DomainDeletionResultLegacy) ProtoReflect() protoreflect.Message { // Deprecated: Use DomainDeletionResultLegacy.ProtoReflect.Descriptor instead. func (*DomainDeletionResultLegacy) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{791} + return file_nico_nico_proto_rawDescGZIP(), []int{793} } // DEPRECATED: Use dns.DomainSearchQuery instead @@ -56110,7 +56201,7 @@ type DomainSearchQueryLegacy struct { func (x *DomainSearchQueryLegacy) Reset() { *x = DomainSearchQueryLegacy{} - mi := &file_nico_nico_proto_msgTypes[792] + mi := &file_nico_nico_proto_msgTypes[794] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56122,7 +56213,7 @@ func (x *DomainSearchQueryLegacy) String() string { func (*DomainSearchQueryLegacy) ProtoMessage() {} func (x *DomainSearchQueryLegacy) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[792] + mi := &file_nico_nico_proto_msgTypes[794] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56135,7 +56226,7 @@ func (x *DomainSearchQueryLegacy) ProtoReflect() protoreflect.Message { // Deprecated: Use DomainSearchQueryLegacy.ProtoReflect.Descriptor instead. func (*DomainSearchQueryLegacy) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{792} + return file_nico_nico_proto_rawDescGZIP(), []int{794} } func (x *DomainSearchQueryLegacy) GetId() *DomainId { @@ -56167,7 +56258,7 @@ type PxeDomain struct { func (x *PxeDomain) Reset() { *x = PxeDomain{} - mi := &file_nico_nico_proto_msgTypes[793] + mi := &file_nico_nico_proto_msgTypes[795] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56179,7 +56270,7 @@ func (x *PxeDomain) String() string { func (*PxeDomain) ProtoMessage() {} func (x *PxeDomain) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[793] + mi := &file_nico_nico_proto_msgTypes[795] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56192,7 +56283,7 @@ func (x *PxeDomain) ProtoReflect() protoreflect.Message { // Deprecated: Use PxeDomain.ProtoReflect.Descriptor instead. func (*PxeDomain) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{793} + return file_nico_nico_proto_rawDescGZIP(), []int{795} } func (x *PxeDomain) GetDomain() isPxeDomain_Domain { @@ -56246,7 +56337,7 @@ type MachinePositionQuery struct { func (x *MachinePositionQuery) Reset() { *x = MachinePositionQuery{} - mi := &file_nico_nico_proto_msgTypes[794] + mi := &file_nico_nico_proto_msgTypes[796] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56258,7 +56349,7 @@ func (x *MachinePositionQuery) String() string { func (*MachinePositionQuery) ProtoMessage() {} func (x *MachinePositionQuery) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[794] + mi := &file_nico_nico_proto_msgTypes[796] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56271,7 +56362,7 @@ func (x *MachinePositionQuery) ProtoReflect() protoreflect.Message { // Deprecated: Use MachinePositionQuery.ProtoReflect.Descriptor instead. func (*MachinePositionQuery) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{794} + return file_nico_nico_proto_rawDescGZIP(), []int{796} } func (x *MachinePositionQuery) GetMachineIds() []*MachineId { @@ -56290,7 +56381,7 @@ type MachinePositionInfoList struct { func (x *MachinePositionInfoList) Reset() { *x = MachinePositionInfoList{} - mi := &file_nico_nico_proto_msgTypes[795] + mi := &file_nico_nico_proto_msgTypes[797] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56302,7 +56393,7 @@ func (x *MachinePositionInfoList) String() string { func (*MachinePositionInfoList) ProtoMessage() {} func (x *MachinePositionInfoList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[795] + mi := &file_nico_nico_proto_msgTypes[797] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56315,7 +56406,7 @@ func (x *MachinePositionInfoList) ProtoReflect() protoreflect.Message { // Deprecated: Use MachinePositionInfoList.ProtoReflect.Descriptor instead. func (*MachinePositionInfoList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{795} + return file_nico_nico_proto_rawDescGZIP(), []int{797} } func (x *MachinePositionInfoList) GetMachinePositionInfo() []*MachinePositionInfo { @@ -56340,7 +56431,7 @@ type MachinePositionInfo struct { func (x *MachinePositionInfo) Reset() { *x = MachinePositionInfo{} - mi := &file_nico_nico_proto_msgTypes[796] + mi := &file_nico_nico_proto_msgTypes[798] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56352,7 +56443,7 @@ func (x *MachinePositionInfo) String() string { func (*MachinePositionInfo) ProtoMessage() {} func (x *MachinePositionInfo) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[796] + mi := &file_nico_nico_proto_msgTypes[798] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56365,7 +56456,7 @@ func (x *MachinePositionInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use MachinePositionInfo.ProtoReflect.Descriptor instead. func (*MachinePositionInfo) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{796} + return file_nico_nico_proto_rawDescGZIP(), []int{798} } func (x *MachinePositionInfo) GetMachineId() *MachineId { @@ -56427,7 +56518,7 @@ type ModifyDPFStateRequest struct { func (x *ModifyDPFStateRequest) Reset() { *x = ModifyDPFStateRequest{} - mi := &file_nico_nico_proto_msgTypes[797] + mi := &file_nico_nico_proto_msgTypes[799] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56439,7 +56530,7 @@ func (x *ModifyDPFStateRequest) String() string { func (*ModifyDPFStateRequest) ProtoMessage() {} func (x *ModifyDPFStateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[797] + mi := &file_nico_nico_proto_msgTypes[799] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56452,7 +56543,7 @@ func (x *ModifyDPFStateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ModifyDPFStateRequest.ProtoReflect.Descriptor instead. func (*ModifyDPFStateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{797} + return file_nico_nico_proto_rawDescGZIP(), []int{799} } func (x *ModifyDPFStateRequest) GetMachineId() *MachineId { @@ -56478,7 +56569,7 @@ type DPFStateResponse struct { func (x *DPFStateResponse) Reset() { *x = DPFStateResponse{} - mi := &file_nico_nico_proto_msgTypes[798] + mi := &file_nico_nico_proto_msgTypes[800] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56490,7 +56581,7 @@ func (x *DPFStateResponse) String() string { func (*DPFStateResponse) ProtoMessage() {} func (x *DPFStateResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[798] + mi := &file_nico_nico_proto_msgTypes[800] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56503,7 +56594,7 @@ func (x *DPFStateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DPFStateResponse.ProtoReflect.Descriptor instead. func (*DPFStateResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{798} + return file_nico_nico_proto_rawDescGZIP(), []int{800} } func (x *DPFStateResponse) GetDpfStates() []*DPFStateResponse_DPFState { @@ -56522,7 +56613,7 @@ type GetDPFStateRequest struct { func (x *GetDPFStateRequest) Reset() { *x = GetDPFStateRequest{} - mi := &file_nico_nico_proto_msgTypes[799] + mi := &file_nico_nico_proto_msgTypes[801] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56534,7 +56625,7 @@ func (x *GetDPFStateRequest) String() string { func (*GetDPFStateRequest) ProtoMessage() {} func (x *GetDPFStateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[799] + mi := &file_nico_nico_proto_msgTypes[801] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56547,7 +56638,7 @@ func (x *GetDPFStateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDPFStateRequest.ProtoReflect.Descriptor instead. func (*GetDPFStateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{799} + return file_nico_nico_proto_rawDescGZIP(), []int{801} } func (x *GetDPFStateRequest) GetMachineIds() []*MachineId { @@ -56566,7 +56657,7 @@ type GetDPFHostSnapshotRequest struct { func (x *GetDPFHostSnapshotRequest) Reset() { *x = GetDPFHostSnapshotRequest{} - mi := &file_nico_nico_proto_msgTypes[800] + mi := &file_nico_nico_proto_msgTypes[802] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56578,7 +56669,7 @@ func (x *GetDPFHostSnapshotRequest) String() string { func (*GetDPFHostSnapshotRequest) ProtoMessage() {} func (x *GetDPFHostSnapshotRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[800] + mi := &file_nico_nico_proto_msgTypes[802] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56591,7 +56682,7 @@ func (x *GetDPFHostSnapshotRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDPFHostSnapshotRequest.ProtoReflect.Descriptor instead. func (*GetDPFHostSnapshotRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{800} + return file_nico_nico_proto_rawDescGZIP(), []int{802} } func (x *GetDPFHostSnapshotRequest) GetHostMachineId() *MachineId { @@ -56613,7 +56704,7 @@ type DPFHostSnapshotResponse struct { func (x *DPFHostSnapshotResponse) Reset() { *x = DPFHostSnapshotResponse{} - mi := &file_nico_nico_proto_msgTypes[801] + mi := &file_nico_nico_proto_msgTypes[803] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56625,7 +56716,7 @@ func (x *DPFHostSnapshotResponse) String() string { func (*DPFHostSnapshotResponse) ProtoMessage() {} func (x *DPFHostSnapshotResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[801] + mi := &file_nico_nico_proto_msgTypes[803] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56638,7 +56729,7 @@ func (x *DPFHostSnapshotResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DPFHostSnapshotResponse.ProtoReflect.Descriptor instead. func (*DPFHostSnapshotResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{801} + return file_nico_nico_proto_rawDescGZIP(), []int{803} } func (x *DPFHostSnapshotResponse) GetJsonPayload() string { @@ -56656,7 +56747,7 @@ type GetDPFServiceVersionsRequest struct { func (x *GetDPFServiceVersionsRequest) Reset() { *x = GetDPFServiceVersionsRequest{} - mi := &file_nico_nico_proto_msgTypes[802] + mi := &file_nico_nico_proto_msgTypes[804] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56668,7 +56759,7 @@ func (x *GetDPFServiceVersionsRequest) String() string { func (*GetDPFServiceVersionsRequest) ProtoMessage() {} func (x *GetDPFServiceVersionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[802] + mi := &file_nico_nico_proto_msgTypes[804] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56681,7 +56772,7 @@ func (x *GetDPFServiceVersionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDPFServiceVersionsRequest.ProtoReflect.Descriptor instead. func (*GetDPFServiceVersionsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{802} + return file_nico_nico_proto_rawDescGZIP(), []int{804} } type DPFServiceVersion struct { @@ -56705,7 +56796,7 @@ type DPFServiceVersion struct { func (x *DPFServiceVersion) Reset() { *x = DPFServiceVersion{} - mi := &file_nico_nico_proto_msgTypes[803] + mi := &file_nico_nico_proto_msgTypes[805] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56717,7 +56808,7 @@ func (x *DPFServiceVersion) String() string { func (*DPFServiceVersion) ProtoMessage() {} func (x *DPFServiceVersion) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[803] + mi := &file_nico_nico_proto_msgTypes[805] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56730,7 +56821,7 @@ func (x *DPFServiceVersion) ProtoReflect() protoreflect.Message { // Deprecated: Use DPFServiceVersion.ProtoReflect.Descriptor instead. func (*DPFServiceVersion) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{803} + return file_nico_nico_proto_rawDescGZIP(), []int{805} } func (x *DPFServiceVersion) GetService() string { @@ -56777,7 +56868,7 @@ type DPFServiceVersionsResponse struct { func (x *DPFServiceVersionsResponse) Reset() { *x = DPFServiceVersionsResponse{} - mi := &file_nico_nico_proto_msgTypes[804] + mi := &file_nico_nico_proto_msgTypes[806] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56789,7 +56880,7 @@ func (x *DPFServiceVersionsResponse) String() string { func (*DPFServiceVersionsResponse) ProtoMessage() {} func (x *DPFServiceVersionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[804] + mi := &file_nico_nico_proto_msgTypes[806] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56802,7 +56893,7 @@ func (x *DPFServiceVersionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DPFServiceVersionsResponse.ProtoReflect.Descriptor instead. func (*DPFServiceVersionsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{804} + return file_nico_nico_proto_rawDescGZIP(), []int{806} } func (x *DPFServiceVersionsResponse) GetServices() []*DPFServiceVersion { @@ -56823,7 +56914,7 @@ type ComponentResult struct { func (x *ComponentResult) Reset() { *x = ComponentResult{} - mi := &file_nico_nico_proto_msgTypes[805] + mi := &file_nico_nico_proto_msgTypes[807] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56835,7 +56926,7 @@ func (x *ComponentResult) String() string { func (*ComponentResult) ProtoMessage() {} func (x *ComponentResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[805] + mi := &file_nico_nico_proto_msgTypes[807] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56848,7 +56939,7 @@ func (x *ComponentResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ComponentResult.ProtoReflect.Descriptor instead. func (*ComponentResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{805} + return file_nico_nico_proto_rawDescGZIP(), []int{807} } func (x *ComponentResult) GetComponentId() string { @@ -56881,7 +56972,7 @@ type SwitchIdList struct { func (x *SwitchIdList) Reset() { *x = SwitchIdList{} - mi := &file_nico_nico_proto_msgTypes[806] + mi := &file_nico_nico_proto_msgTypes[808] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56893,7 +56984,7 @@ func (x *SwitchIdList) String() string { func (*SwitchIdList) ProtoMessage() {} func (x *SwitchIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[806] + mi := &file_nico_nico_proto_msgTypes[808] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56906,7 +56997,7 @@ func (x *SwitchIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use SwitchIdList.ProtoReflect.Descriptor instead. func (*SwitchIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{806} + return file_nico_nico_proto_rawDescGZIP(), []int{808} } func (x *SwitchIdList) GetIds() []*SwitchId { @@ -56925,7 +57016,7 @@ type PowerShelfIdList struct { func (x *PowerShelfIdList) Reset() { *x = PowerShelfIdList{} - mi := &file_nico_nico_proto_msgTypes[807] + mi := &file_nico_nico_proto_msgTypes[809] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56937,7 +57028,7 @@ func (x *PowerShelfIdList) String() string { func (*PowerShelfIdList) ProtoMessage() {} func (x *PowerShelfIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[807] + mi := &file_nico_nico_proto_msgTypes[809] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56950,7 +57041,7 @@ func (x *PowerShelfIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use PowerShelfIdList.ProtoReflect.Descriptor instead. func (*PowerShelfIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{807} + return file_nico_nico_proto_rawDescGZIP(), []int{809} } func (x *PowerShelfIdList) GetIds() []*PowerShelfId { @@ -56974,7 +57065,7 @@ type GetComponentInventoryRequest struct { func (x *GetComponentInventoryRequest) Reset() { *x = GetComponentInventoryRequest{} - mi := &file_nico_nico_proto_msgTypes[808] + mi := &file_nico_nico_proto_msgTypes[810] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -56986,7 +57077,7 @@ func (x *GetComponentInventoryRequest) String() string { func (*GetComponentInventoryRequest) ProtoMessage() {} func (x *GetComponentInventoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[808] + mi := &file_nico_nico_proto_msgTypes[810] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -56999,7 +57090,7 @@ func (x *GetComponentInventoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetComponentInventoryRequest.ProtoReflect.Descriptor instead. func (*GetComponentInventoryRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{808} + return file_nico_nico_proto_rawDescGZIP(), []int{810} } func (x *GetComponentInventoryRequest) GetTarget() isGetComponentInventoryRequest_Target { @@ -57068,7 +57159,7 @@ type ComponentInventoryEntry struct { func (x *ComponentInventoryEntry) Reset() { *x = ComponentInventoryEntry{} - mi := &file_nico_nico_proto_msgTypes[809] + mi := &file_nico_nico_proto_msgTypes[811] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57080,7 +57171,7 @@ func (x *ComponentInventoryEntry) String() string { func (*ComponentInventoryEntry) ProtoMessage() {} func (x *ComponentInventoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[809] + mi := &file_nico_nico_proto_msgTypes[811] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57093,7 +57184,7 @@ func (x *ComponentInventoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use ComponentInventoryEntry.ProtoReflect.Descriptor instead. func (*ComponentInventoryEntry) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{809} + return file_nico_nico_proto_rawDescGZIP(), []int{811} } func (x *ComponentInventoryEntry) GetResult() *ComponentResult { @@ -57119,7 +57210,7 @@ type GetComponentInventoryResponse struct { func (x *GetComponentInventoryResponse) Reset() { *x = GetComponentInventoryResponse{} - mi := &file_nico_nico_proto_msgTypes[810] + mi := &file_nico_nico_proto_msgTypes[812] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57131,7 +57222,7 @@ func (x *GetComponentInventoryResponse) String() string { func (*GetComponentInventoryResponse) ProtoMessage() {} func (x *GetComponentInventoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[810] + mi := &file_nico_nico_proto_msgTypes[812] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57144,7 +57235,7 @@ func (x *GetComponentInventoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetComponentInventoryResponse.ProtoReflect.Descriptor instead. func (*GetComponentInventoryResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{810} + return file_nico_nico_proto_rawDescGZIP(), []int{812} } func (x *GetComponentInventoryResponse) GetEntries() []*ComponentInventoryEntry { @@ -57172,7 +57263,7 @@ type ComponentPowerControlRequest struct { func (x *ComponentPowerControlRequest) Reset() { *x = ComponentPowerControlRequest{} - mi := &file_nico_nico_proto_msgTypes[811] + mi := &file_nico_nico_proto_msgTypes[813] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57184,7 +57275,7 @@ func (x *ComponentPowerControlRequest) String() string { func (*ComponentPowerControlRequest) ProtoMessage() {} func (x *ComponentPowerControlRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[811] + mi := &file_nico_nico_proto_msgTypes[813] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57197,7 +57288,7 @@ func (x *ComponentPowerControlRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ComponentPowerControlRequest.ProtoReflect.Descriptor instead. func (*ComponentPowerControlRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{811} + return file_nico_nico_proto_rawDescGZIP(), []int{813} } func (x *ComponentPowerControlRequest) GetTarget() isComponentPowerControlRequest_Target { @@ -57279,7 +57370,7 @@ type ComponentPowerControlResponse struct { func (x *ComponentPowerControlResponse) Reset() { *x = ComponentPowerControlResponse{} - mi := &file_nico_nico_proto_msgTypes[812] + mi := &file_nico_nico_proto_msgTypes[814] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57291,7 +57382,7 @@ func (x *ComponentPowerControlResponse) String() string { func (*ComponentPowerControlResponse) ProtoMessage() {} func (x *ComponentPowerControlResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[812] + mi := &file_nico_nico_proto_msgTypes[814] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57304,7 +57395,7 @@ func (x *ComponentPowerControlResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ComponentPowerControlResponse.ProtoReflect.Descriptor instead. func (*ComponentPowerControlResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{812} + return file_nico_nico_proto_rawDescGZIP(), []int{814} } func (x *ComponentPowerControlResponse) GetResults() []*ComponentResult { @@ -57328,7 +57419,7 @@ type ComponentConfigureSwitchCertificateRequest struct { func (x *ComponentConfigureSwitchCertificateRequest) Reset() { *x = ComponentConfigureSwitchCertificateRequest{} - mi := &file_nico_nico_proto_msgTypes[813] + mi := &file_nico_nico_proto_msgTypes[815] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57340,7 +57431,7 @@ func (x *ComponentConfigureSwitchCertificateRequest) String() string { func (*ComponentConfigureSwitchCertificateRequest) ProtoMessage() {} func (x *ComponentConfigureSwitchCertificateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[813] + mi := &file_nico_nico_proto_msgTypes[815] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57353,7 +57444,7 @@ func (x *ComponentConfigureSwitchCertificateRequest) ProtoReflect() protoreflect // Deprecated: Use ComponentConfigureSwitchCertificateRequest.ProtoReflect.Descriptor instead. func (*ComponentConfigureSwitchCertificateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{813} + return file_nico_nico_proto_rawDescGZIP(), []int{815} } func (x *ComponentConfigureSwitchCertificateRequest) GetSwitchIds() *SwitchIdList { @@ -57386,7 +57477,7 @@ type ComponentConfigureSwitchCertificateResponse struct { func (x *ComponentConfigureSwitchCertificateResponse) Reset() { *x = ComponentConfigureSwitchCertificateResponse{} - mi := &file_nico_nico_proto_msgTypes[814] + mi := &file_nico_nico_proto_msgTypes[816] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57398,7 +57489,7 @@ func (x *ComponentConfigureSwitchCertificateResponse) String() string { func (*ComponentConfigureSwitchCertificateResponse) ProtoMessage() {} func (x *ComponentConfigureSwitchCertificateResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[814] + mi := &file_nico_nico_proto_msgTypes[816] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57411,7 +57502,7 @@ func (x *ComponentConfigureSwitchCertificateResponse) ProtoReflect() protoreflec // Deprecated: Use ComponentConfigureSwitchCertificateResponse.ProtoReflect.Descriptor instead. func (*ComponentConfigureSwitchCertificateResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{814} + return file_nico_nico_proto_rawDescGZIP(), []int{816} } func (x *ComponentConfigureSwitchCertificateResponse) GetResults() []*ComponentResult { @@ -57433,7 +57524,7 @@ type FirmwareUpdateStatus struct { func (x *FirmwareUpdateStatus) Reset() { *x = FirmwareUpdateStatus{} - mi := &file_nico_nico_proto_msgTypes[815] + mi := &file_nico_nico_proto_msgTypes[817] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57445,7 +57536,7 @@ func (x *FirmwareUpdateStatus) String() string { func (*FirmwareUpdateStatus) ProtoMessage() {} func (x *FirmwareUpdateStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[815] + mi := &file_nico_nico_proto_msgTypes[817] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57458,7 +57549,7 @@ func (x *FirmwareUpdateStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use FirmwareUpdateStatus.ProtoReflect.Descriptor instead. func (*FirmwareUpdateStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{815} + return file_nico_nico_proto_rawDescGZIP(), []int{817} } func (x *FirmwareUpdateStatus) GetResult() *ComponentResult { @@ -57499,7 +57590,7 @@ type UpdateComputeTrayFirmwareTarget struct { func (x *UpdateComputeTrayFirmwareTarget) Reset() { *x = UpdateComputeTrayFirmwareTarget{} - mi := &file_nico_nico_proto_msgTypes[816] + mi := &file_nico_nico_proto_msgTypes[818] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57511,7 +57602,7 @@ func (x *UpdateComputeTrayFirmwareTarget) String() string { func (*UpdateComputeTrayFirmwareTarget) ProtoMessage() {} func (x *UpdateComputeTrayFirmwareTarget) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[816] + mi := &file_nico_nico_proto_msgTypes[818] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57524,7 +57615,7 @@ func (x *UpdateComputeTrayFirmwareTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateComputeTrayFirmwareTarget.ProtoReflect.Descriptor instead. func (*UpdateComputeTrayFirmwareTarget) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{816} + return file_nico_nico_proto_rawDescGZIP(), []int{818} } func (x *UpdateComputeTrayFirmwareTarget) GetMachineIds() *MachineIdList { @@ -57551,7 +57642,7 @@ type UpdateSwitchFirmwareTarget struct { func (x *UpdateSwitchFirmwareTarget) Reset() { *x = UpdateSwitchFirmwareTarget{} - mi := &file_nico_nico_proto_msgTypes[817] + mi := &file_nico_nico_proto_msgTypes[819] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57563,7 +57654,7 @@ func (x *UpdateSwitchFirmwareTarget) String() string { func (*UpdateSwitchFirmwareTarget) ProtoMessage() {} func (x *UpdateSwitchFirmwareTarget) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[817] + mi := &file_nico_nico_proto_msgTypes[819] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57576,7 +57667,7 @@ func (x *UpdateSwitchFirmwareTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateSwitchFirmwareTarget.ProtoReflect.Descriptor instead. func (*UpdateSwitchFirmwareTarget) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{817} + return file_nico_nico_proto_rawDescGZIP(), []int{819} } func (x *UpdateSwitchFirmwareTarget) GetSwitchIds() *SwitchIdList { @@ -57603,7 +57694,7 @@ type UpdatePowerShelfFirmwareTarget struct { func (x *UpdatePowerShelfFirmwareTarget) Reset() { *x = UpdatePowerShelfFirmwareTarget{} - mi := &file_nico_nico_proto_msgTypes[818] + mi := &file_nico_nico_proto_msgTypes[820] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57615,7 +57706,7 @@ func (x *UpdatePowerShelfFirmwareTarget) String() string { func (*UpdatePowerShelfFirmwareTarget) ProtoMessage() {} func (x *UpdatePowerShelfFirmwareTarget) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[818] + mi := &file_nico_nico_proto_msgTypes[820] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57628,7 +57719,7 @@ func (x *UpdatePowerShelfFirmwareTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdatePowerShelfFirmwareTarget.ProtoReflect.Descriptor instead. func (*UpdatePowerShelfFirmwareTarget) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{818} + return file_nico_nico_proto_rawDescGZIP(), []int{820} } func (x *UpdatePowerShelfFirmwareTarget) GetPowerShelfIds() *PowerShelfIdList { @@ -57656,7 +57747,7 @@ type UpdateFirmwareObjectTarget struct { func (x *UpdateFirmwareObjectTarget) Reset() { *x = UpdateFirmwareObjectTarget{} - mi := &file_nico_nico_proto_msgTypes[819] + mi := &file_nico_nico_proto_msgTypes[821] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57668,7 +57759,7 @@ func (x *UpdateFirmwareObjectTarget) String() string { func (*UpdateFirmwareObjectTarget) ProtoMessage() {} func (x *UpdateFirmwareObjectTarget) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[819] + mi := &file_nico_nico_proto_msgTypes[821] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57681,7 +57772,7 @@ func (x *UpdateFirmwareObjectTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateFirmwareObjectTarget.ProtoReflect.Descriptor instead. func (*UpdateFirmwareObjectTarget) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{819} + return file_nico_nico_proto_rawDescGZIP(), []int{821} } func (x *UpdateFirmwareObjectTarget) GetRackIds() *RackIdList { @@ -57718,7 +57809,7 @@ type UpdateComponentFirmwareRequest struct { func (x *UpdateComponentFirmwareRequest) Reset() { *x = UpdateComponentFirmwareRequest{} - mi := &file_nico_nico_proto_msgTypes[820] + mi := &file_nico_nico_proto_msgTypes[822] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57730,7 +57821,7 @@ func (x *UpdateComponentFirmwareRequest) String() string { func (*UpdateComponentFirmwareRequest) ProtoMessage() {} func (x *UpdateComponentFirmwareRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[820] + mi := &file_nico_nico_proto_msgTypes[822] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57743,7 +57834,7 @@ func (x *UpdateComponentFirmwareRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateComponentFirmwareRequest.ProtoReflect.Descriptor instead. func (*UpdateComponentFirmwareRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{820} + return file_nico_nico_proto_rawDescGZIP(), []int{822} } func (x *UpdateComponentFirmwareRequest) GetTarget() isUpdateComponentFirmwareRequest_Target { @@ -57855,7 +57946,7 @@ type UpdateComponentFirmwareResponse struct { func (x *UpdateComponentFirmwareResponse) Reset() { *x = UpdateComponentFirmwareResponse{} - mi := &file_nico_nico_proto_msgTypes[821] + mi := &file_nico_nico_proto_msgTypes[823] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57867,7 +57958,7 @@ func (x *UpdateComponentFirmwareResponse) String() string { func (*UpdateComponentFirmwareResponse) ProtoMessage() {} func (x *UpdateComponentFirmwareResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[821] + mi := &file_nico_nico_proto_msgTypes[823] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57880,7 +57971,7 @@ func (x *UpdateComponentFirmwareResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateComponentFirmwareResponse.ProtoReflect.Descriptor instead. func (*UpdateComponentFirmwareResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{821} + return file_nico_nico_proto_rawDescGZIP(), []int{823} } func (x *UpdateComponentFirmwareResponse) GetResults() []*ComponentResult { @@ -57905,7 +57996,7 @@ type GetComponentFirmwareStatusRequest struct { func (x *GetComponentFirmwareStatusRequest) Reset() { *x = GetComponentFirmwareStatusRequest{} - mi := &file_nico_nico_proto_msgTypes[822] + mi := &file_nico_nico_proto_msgTypes[824] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -57917,7 +58008,7 @@ func (x *GetComponentFirmwareStatusRequest) String() string { func (*GetComponentFirmwareStatusRequest) ProtoMessage() {} func (x *GetComponentFirmwareStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[822] + mi := &file_nico_nico_proto_msgTypes[824] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -57930,7 +58021,7 @@ func (x *GetComponentFirmwareStatusRequest) ProtoReflect() protoreflect.Message // Deprecated: Use GetComponentFirmwareStatusRequest.ProtoReflect.Descriptor instead. func (*GetComponentFirmwareStatusRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{822} + return file_nico_nico_proto_rawDescGZIP(), []int{824} } func (x *GetComponentFirmwareStatusRequest) GetTarget() isGetComponentFirmwareStatusRequest_Target { @@ -58014,7 +58105,7 @@ type GetComponentFirmwareStatusResponse struct { func (x *GetComponentFirmwareStatusResponse) Reset() { *x = GetComponentFirmwareStatusResponse{} - mi := &file_nico_nico_proto_msgTypes[823] + mi := &file_nico_nico_proto_msgTypes[825] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58026,7 +58117,7 @@ func (x *GetComponentFirmwareStatusResponse) String() string { func (*GetComponentFirmwareStatusResponse) ProtoMessage() {} func (x *GetComponentFirmwareStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[823] + mi := &file_nico_nico_proto_msgTypes[825] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58039,7 +58130,7 @@ func (x *GetComponentFirmwareStatusResponse) ProtoReflect() protoreflect.Message // Deprecated: Use GetComponentFirmwareStatusResponse.ProtoReflect.Descriptor instead. func (*GetComponentFirmwareStatusResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{823} + return file_nico_nico_proto_rawDescGZIP(), []int{825} } func (x *GetComponentFirmwareStatusResponse) GetStatuses() []*FirmwareUpdateStatus { @@ -58064,7 +58155,7 @@ type ListComponentFirmwareVersionsRequest struct { func (x *ListComponentFirmwareVersionsRequest) Reset() { *x = ListComponentFirmwareVersionsRequest{} - mi := &file_nico_nico_proto_msgTypes[824] + mi := &file_nico_nico_proto_msgTypes[826] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58076,7 +58167,7 @@ func (x *ListComponentFirmwareVersionsRequest) String() string { func (*ListComponentFirmwareVersionsRequest) ProtoMessage() {} func (x *ListComponentFirmwareVersionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[824] + mi := &file_nico_nico_proto_msgTypes[826] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58089,7 +58180,7 @@ func (x *ListComponentFirmwareVersionsRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use ListComponentFirmwareVersionsRequest.ProtoReflect.Descriptor instead. func (*ListComponentFirmwareVersionsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{824} + return file_nico_nico_proto_rawDescGZIP(), []int{826} } func (x *ListComponentFirmwareVersionsRequest) GetTarget() isListComponentFirmwareVersionsRequest_Target { @@ -58180,7 +58271,7 @@ type ComputeTrayFirmwareVersions struct { func (x *ComputeTrayFirmwareVersions) Reset() { *x = ComputeTrayFirmwareVersions{} - mi := &file_nico_nico_proto_msgTypes[825] + mi := &file_nico_nico_proto_msgTypes[827] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58192,7 +58283,7 @@ func (x *ComputeTrayFirmwareVersions) String() string { func (*ComputeTrayFirmwareVersions) ProtoMessage() {} func (x *ComputeTrayFirmwareVersions) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[825] + mi := &file_nico_nico_proto_msgTypes[827] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58205,7 +58296,7 @@ func (x *ComputeTrayFirmwareVersions) ProtoReflect() protoreflect.Message { // Deprecated: Use ComputeTrayFirmwareVersions.ProtoReflect.Descriptor instead. func (*ComputeTrayFirmwareVersions) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{825} + return file_nico_nico_proto_rawDescGZIP(), []int{827} } func (x *ComputeTrayFirmwareVersions) GetComponent() ComputeTrayComponent { @@ -58235,7 +58326,7 @@ type DeviceFirmwareVersions struct { func (x *DeviceFirmwareVersions) Reset() { *x = DeviceFirmwareVersions{} - mi := &file_nico_nico_proto_msgTypes[826] + mi := &file_nico_nico_proto_msgTypes[828] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58247,7 +58338,7 @@ func (x *DeviceFirmwareVersions) String() string { func (*DeviceFirmwareVersions) ProtoMessage() {} func (x *DeviceFirmwareVersions) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[826] + mi := &file_nico_nico_proto_msgTypes[828] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58260,7 +58351,7 @@ func (x *DeviceFirmwareVersions) ProtoReflect() protoreflect.Message { // Deprecated: Use DeviceFirmwareVersions.ProtoReflect.Descriptor instead. func (*DeviceFirmwareVersions) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{826} + return file_nico_nico_proto_rawDescGZIP(), []int{828} } func (x *DeviceFirmwareVersions) GetResult() *ComponentResult { @@ -58293,7 +58384,7 @@ type ListComponentFirmwareVersionsResponse struct { func (x *ListComponentFirmwareVersionsResponse) Reset() { *x = ListComponentFirmwareVersionsResponse{} - mi := &file_nico_nico_proto_msgTypes[827] + mi := &file_nico_nico_proto_msgTypes[829] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58305,7 +58396,7 @@ func (x *ListComponentFirmwareVersionsResponse) String() string { func (*ListComponentFirmwareVersionsResponse) ProtoMessage() {} func (x *ListComponentFirmwareVersionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[827] + mi := &file_nico_nico_proto_msgTypes[829] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58318,7 +58409,7 @@ func (x *ListComponentFirmwareVersionsResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use ListComponentFirmwareVersionsResponse.ProtoReflect.Descriptor instead. func (*ListComponentFirmwareVersionsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{827} + return file_nico_nico_proto_rawDescGZIP(), []int{829} } func (x *ListComponentFirmwareVersionsResponse) GetDevices() []*DeviceFirmwareVersions { @@ -58340,7 +58431,7 @@ type SpxPartitionCreationRequest struct { func (x *SpxPartitionCreationRequest) Reset() { *x = SpxPartitionCreationRequest{} - mi := &file_nico_nico_proto_msgTypes[828] + mi := &file_nico_nico_proto_msgTypes[830] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58352,7 +58443,7 @@ func (x *SpxPartitionCreationRequest) String() string { func (*SpxPartitionCreationRequest) ProtoMessage() {} func (x *SpxPartitionCreationRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[828] + mi := &file_nico_nico_proto_msgTypes[830] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58365,7 +58456,7 @@ func (x *SpxPartitionCreationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionCreationRequest.ProtoReflect.Descriptor instead. func (*SpxPartitionCreationRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{828} + return file_nico_nico_proto_rawDescGZIP(), []int{830} } func (x *SpxPartitionCreationRequest) GetMetadata() *Metadata { @@ -58408,7 +58499,7 @@ type SpxPartition struct { func (x *SpxPartition) Reset() { *x = SpxPartition{} - mi := &file_nico_nico_proto_msgTypes[829] + mi := &file_nico_nico_proto_msgTypes[831] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58420,7 +58511,7 @@ func (x *SpxPartition) String() string { func (*SpxPartition) ProtoMessage() {} func (x *SpxPartition) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[829] + mi := &file_nico_nico_proto_msgTypes[831] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58433,7 +58524,7 @@ func (x *SpxPartition) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartition.ProtoReflect.Descriptor instead. func (*SpxPartition) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{829} + return file_nico_nico_proto_rawDescGZIP(), []int{831} } func (x *SpxPartition) GetMetadata() *Metadata { @@ -58473,7 +58564,7 @@ type SpxPartitionIdList struct { func (x *SpxPartitionIdList) Reset() { *x = SpxPartitionIdList{} - mi := &file_nico_nico_proto_msgTypes[830] + mi := &file_nico_nico_proto_msgTypes[832] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58485,7 +58576,7 @@ func (x *SpxPartitionIdList) String() string { func (*SpxPartitionIdList) ProtoMessage() {} func (x *SpxPartitionIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[830] + mi := &file_nico_nico_proto_msgTypes[832] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58498,7 +58589,7 @@ func (x *SpxPartitionIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionIdList.ProtoReflect.Descriptor instead. func (*SpxPartitionIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{830} + return file_nico_nico_proto_rawDescGZIP(), []int{832} } func (x *SpxPartitionIdList) GetSpxPartitionIds() []*SpxPartitionId { @@ -58517,7 +58608,7 @@ type SpxPartitionDeletionRequest struct { func (x *SpxPartitionDeletionRequest) Reset() { *x = SpxPartitionDeletionRequest{} - mi := &file_nico_nico_proto_msgTypes[831] + mi := &file_nico_nico_proto_msgTypes[833] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58529,7 +58620,7 @@ func (x *SpxPartitionDeletionRequest) String() string { func (*SpxPartitionDeletionRequest) ProtoMessage() {} func (x *SpxPartitionDeletionRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[831] + mi := &file_nico_nico_proto_msgTypes[833] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58542,7 +58633,7 @@ func (x *SpxPartitionDeletionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionDeletionRequest.ProtoReflect.Descriptor instead. func (*SpxPartitionDeletionRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{831} + return file_nico_nico_proto_rawDescGZIP(), []int{833} } func (x *SpxPartitionDeletionRequest) GetId() *SpxPartitionId { @@ -58560,7 +58651,7 @@ type SpxPartitionDeletionResult struct { func (x *SpxPartitionDeletionResult) Reset() { *x = SpxPartitionDeletionResult{} - mi := &file_nico_nico_proto_msgTypes[832] + mi := &file_nico_nico_proto_msgTypes[834] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58572,7 +58663,7 @@ func (x *SpxPartitionDeletionResult) String() string { func (*SpxPartitionDeletionResult) ProtoMessage() {} func (x *SpxPartitionDeletionResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[832] + mi := &file_nico_nico_proto_msgTypes[834] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58585,7 +58676,7 @@ func (x *SpxPartitionDeletionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionDeletionResult.ProtoReflect.Descriptor instead. func (*SpxPartitionDeletionResult) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{832} + return file_nico_nico_proto_rawDescGZIP(), []int{834} } type SpxPartitionSearchFilter struct { @@ -58599,7 +58690,7 @@ type SpxPartitionSearchFilter struct { func (x *SpxPartitionSearchFilter) Reset() { *x = SpxPartitionSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[833] + mi := &file_nico_nico_proto_msgTypes[835] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58611,7 +58702,7 @@ func (x *SpxPartitionSearchFilter) String() string { func (*SpxPartitionSearchFilter) ProtoMessage() {} func (x *SpxPartitionSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[833] + mi := &file_nico_nico_proto_msgTypes[835] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58624,7 +58715,7 @@ func (x *SpxPartitionSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionSearchFilter.ProtoReflect.Descriptor instead. func (*SpxPartitionSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{833} + return file_nico_nico_proto_rawDescGZIP(), []int{835} } func (x *SpxPartitionSearchFilter) GetName() string { @@ -58657,7 +58748,7 @@ type SpxPartitionList struct { func (x *SpxPartitionList) Reset() { *x = SpxPartitionList{} - mi := &file_nico_nico_proto_msgTypes[834] + mi := &file_nico_nico_proto_msgTypes[836] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58669,7 +58760,7 @@ func (x *SpxPartitionList) String() string { func (*SpxPartitionList) ProtoMessage() {} func (x *SpxPartitionList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[834] + mi := &file_nico_nico_proto_msgTypes[836] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58682,7 +58773,7 @@ func (x *SpxPartitionList) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionList.ProtoReflect.Descriptor instead. func (*SpxPartitionList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{834} + return file_nico_nico_proto_rawDescGZIP(), []int{836} } func (x *SpxPartitionList) GetSpxPartitions() []*SpxPartition { @@ -58701,7 +58792,7 @@ type SpxPartitionsByIdsRequest struct { func (x *SpxPartitionsByIdsRequest) Reset() { *x = SpxPartitionsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[835] + mi := &file_nico_nico_proto_msgTypes[837] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58713,7 +58804,7 @@ func (x *SpxPartitionsByIdsRequest) String() string { func (*SpxPartitionsByIdsRequest) ProtoMessage() {} func (x *SpxPartitionsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[835] + mi := &file_nico_nico_proto_msgTypes[837] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58726,7 +58817,7 @@ func (x *SpxPartitionsByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SpxPartitionsByIdsRequest.ProtoReflect.Descriptor instead. func (*SpxPartitionsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{835} + return file_nico_nico_proto_rawDescGZIP(), []int{837} } func (x *SpxPartitionsByIdsRequest) GetSpxPartitionIds() []*SpxPartitionId { @@ -58749,7 +58840,7 @@ type AdminForceDeleteSwitchRequest struct { func (x *AdminForceDeleteSwitchRequest) Reset() { *x = AdminForceDeleteSwitchRequest{} - mi := &file_nico_nico_proto_msgTypes[836] + mi := &file_nico_nico_proto_msgTypes[838] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58761,7 +58852,7 @@ func (x *AdminForceDeleteSwitchRequest) String() string { func (*AdminForceDeleteSwitchRequest) ProtoMessage() {} func (x *AdminForceDeleteSwitchRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[836] + mi := &file_nico_nico_proto_msgTypes[838] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58774,7 +58865,7 @@ func (x *AdminForceDeleteSwitchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AdminForceDeleteSwitchRequest.ProtoReflect.Descriptor instead. func (*AdminForceDeleteSwitchRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{836} + return file_nico_nico_proto_rawDescGZIP(), []int{838} } func (x *AdminForceDeleteSwitchRequest) GetSwitchId() *SwitchId { @@ -58803,7 +58894,7 @@ type AdminForceDeleteSwitchResponse struct { func (x *AdminForceDeleteSwitchResponse) Reset() { *x = AdminForceDeleteSwitchResponse{} - mi := &file_nico_nico_proto_msgTypes[837] + mi := &file_nico_nico_proto_msgTypes[839] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58815,7 +58906,7 @@ func (x *AdminForceDeleteSwitchResponse) String() string { func (*AdminForceDeleteSwitchResponse) ProtoMessage() {} func (x *AdminForceDeleteSwitchResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[837] + mi := &file_nico_nico_proto_msgTypes[839] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58828,7 +58919,7 @@ func (x *AdminForceDeleteSwitchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AdminForceDeleteSwitchResponse.ProtoReflect.Descriptor instead. func (*AdminForceDeleteSwitchResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{837} + return file_nico_nico_proto_rawDescGZIP(), []int{839} } func (x *AdminForceDeleteSwitchResponse) GetSwitchId() string { @@ -58858,7 +58949,7 @@ type AdminForceDeletePowerShelfRequest struct { func (x *AdminForceDeletePowerShelfRequest) Reset() { *x = AdminForceDeletePowerShelfRequest{} - mi := &file_nico_nico_proto_msgTypes[838] + mi := &file_nico_nico_proto_msgTypes[840] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58870,7 +58961,7 @@ func (x *AdminForceDeletePowerShelfRequest) String() string { func (*AdminForceDeletePowerShelfRequest) ProtoMessage() {} func (x *AdminForceDeletePowerShelfRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[838] + mi := &file_nico_nico_proto_msgTypes[840] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58883,7 +58974,7 @@ func (x *AdminForceDeletePowerShelfRequest) ProtoReflect() protoreflect.Message // Deprecated: Use AdminForceDeletePowerShelfRequest.ProtoReflect.Descriptor instead. func (*AdminForceDeletePowerShelfRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{838} + return file_nico_nico_proto_rawDescGZIP(), []int{840} } func (x *AdminForceDeletePowerShelfRequest) GetPowerShelfId() *PowerShelfId { @@ -58912,7 +59003,7 @@ type AdminForceDeletePowerShelfResponse struct { func (x *AdminForceDeletePowerShelfResponse) Reset() { *x = AdminForceDeletePowerShelfResponse{} - mi := &file_nico_nico_proto_msgTypes[839] + mi := &file_nico_nico_proto_msgTypes[841] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58924,7 +59015,7 @@ func (x *AdminForceDeletePowerShelfResponse) String() string { func (*AdminForceDeletePowerShelfResponse) ProtoMessage() {} func (x *AdminForceDeletePowerShelfResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[839] + mi := &file_nico_nico_proto_msgTypes[841] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -58937,7 +59028,7 @@ func (x *AdminForceDeletePowerShelfResponse) ProtoReflect() protoreflect.Message // Deprecated: Use AdminForceDeletePowerShelfResponse.ProtoReflect.Descriptor instead. func (*AdminForceDeletePowerShelfResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{839} + return file_nico_nico_proto_rawDescGZIP(), []int{841} } func (x *AdminForceDeletePowerShelfResponse) GetPowerShelfId() string { @@ -58981,7 +59072,7 @@ type OperatingSystem struct { func (x *OperatingSystem) Reset() { *x = OperatingSystem{} - mi := &file_nico_nico_proto_msgTypes[840] + mi := &file_nico_nico_proto_msgTypes[842] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -58993,7 +59084,7 @@ func (x *OperatingSystem) String() string { func (*OperatingSystem) ProtoMessage() {} func (x *OperatingSystem) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[840] + mi := &file_nico_nico_proto_msgTypes[842] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59006,7 +59097,7 @@ func (x *OperatingSystem) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatingSystem.ProtoReflect.Descriptor instead. func (*OperatingSystem) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{840} + return file_nico_nico_proto_rawDescGZIP(), []int{842} } func (x *OperatingSystem) GetId() *OperatingSystemId { @@ -59151,7 +59242,7 @@ type CreateOperatingSystemRequest struct { func (x *CreateOperatingSystemRequest) Reset() { *x = CreateOperatingSystemRequest{} - mi := &file_nico_nico_proto_msgTypes[841] + mi := &file_nico_nico_proto_msgTypes[843] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59163,7 +59254,7 @@ func (x *CreateOperatingSystemRequest) String() string { func (*CreateOperatingSystemRequest) ProtoMessage() {} func (x *CreateOperatingSystemRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[841] + mi := &file_nico_nico_proto_msgTypes[843] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59176,7 +59267,7 @@ func (x *CreateOperatingSystemRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateOperatingSystemRequest.ProtoReflect.Descriptor instead. func (*CreateOperatingSystemRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{841} + return file_nico_nico_proto_rawDescGZIP(), []int{843} } func (x *CreateOperatingSystemRequest) GetName() string { @@ -59274,7 +59365,7 @@ type IpxeTemplateParameters struct { func (x *IpxeTemplateParameters) Reset() { *x = IpxeTemplateParameters{} - mi := &file_nico_nico_proto_msgTypes[842] + mi := &file_nico_nico_proto_msgTypes[844] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59286,7 +59377,7 @@ func (x *IpxeTemplateParameters) String() string { func (*IpxeTemplateParameters) ProtoMessage() {} func (x *IpxeTemplateParameters) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[842] + mi := &file_nico_nico_proto_msgTypes[844] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59299,7 +59390,7 @@ func (x *IpxeTemplateParameters) ProtoReflect() protoreflect.Message { // Deprecated: Use IpxeTemplateParameters.ProtoReflect.Descriptor instead. func (*IpxeTemplateParameters) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{842} + return file_nico_nico_proto_rawDescGZIP(), []int{844} } func (x *IpxeTemplateParameters) GetItems() []*IpxeTemplateParameter { @@ -59319,7 +59410,7 @@ type IpxeTemplateArtifacts struct { func (x *IpxeTemplateArtifacts) Reset() { *x = IpxeTemplateArtifacts{} - mi := &file_nico_nico_proto_msgTypes[843] + mi := &file_nico_nico_proto_msgTypes[845] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59331,7 +59422,7 @@ func (x *IpxeTemplateArtifacts) String() string { func (*IpxeTemplateArtifacts) ProtoMessage() {} func (x *IpxeTemplateArtifacts) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[843] + mi := &file_nico_nico_proto_msgTypes[845] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59344,7 +59435,7 @@ func (x *IpxeTemplateArtifacts) ProtoReflect() protoreflect.Message { // Deprecated: Use IpxeTemplateArtifacts.ProtoReflect.Descriptor instead. func (*IpxeTemplateArtifacts) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{843} + return file_nico_nico_proto_rawDescGZIP(), []int{845} } func (x *IpxeTemplateArtifacts) GetItems() []*IpxeTemplateArtifact { @@ -59374,7 +59465,7 @@ type UpdateOperatingSystemRequest struct { func (x *UpdateOperatingSystemRequest) Reset() { *x = UpdateOperatingSystemRequest{} - mi := &file_nico_nico_proto_msgTypes[844] + mi := &file_nico_nico_proto_msgTypes[846] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59386,7 +59477,7 @@ func (x *UpdateOperatingSystemRequest) String() string { func (*UpdateOperatingSystemRequest) ProtoMessage() {} func (x *UpdateOperatingSystemRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[844] + mi := &file_nico_nico_proto_msgTypes[846] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59399,7 +59490,7 @@ func (x *UpdateOperatingSystemRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateOperatingSystemRequest.ProtoReflect.Descriptor instead. func (*UpdateOperatingSystemRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{844} + return file_nico_nico_proto_rawDescGZIP(), []int{846} } func (x *UpdateOperatingSystemRequest) GetId() *OperatingSystemId { @@ -59495,7 +59586,7 @@ type DeleteOperatingSystemRequest struct { func (x *DeleteOperatingSystemRequest) Reset() { *x = DeleteOperatingSystemRequest{} - mi := &file_nico_nico_proto_msgTypes[845] + mi := &file_nico_nico_proto_msgTypes[847] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59507,7 +59598,7 @@ func (x *DeleteOperatingSystemRequest) String() string { func (*DeleteOperatingSystemRequest) ProtoMessage() {} func (x *DeleteOperatingSystemRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[845] + mi := &file_nico_nico_proto_msgTypes[847] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59520,7 +59611,7 @@ func (x *DeleteOperatingSystemRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteOperatingSystemRequest.ProtoReflect.Descriptor instead. func (*DeleteOperatingSystemRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{845} + return file_nico_nico_proto_rawDescGZIP(), []int{847} } func (x *DeleteOperatingSystemRequest) GetId() *OperatingSystemId { @@ -59538,7 +59629,7 @@ type DeleteOperatingSystemResponse struct { func (x *DeleteOperatingSystemResponse) Reset() { *x = DeleteOperatingSystemResponse{} - mi := &file_nico_nico_proto_msgTypes[846] + mi := &file_nico_nico_proto_msgTypes[848] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59550,7 +59641,7 @@ func (x *DeleteOperatingSystemResponse) String() string { func (*DeleteOperatingSystemResponse) ProtoMessage() {} func (x *DeleteOperatingSystemResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[846] + mi := &file_nico_nico_proto_msgTypes[848] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59563,7 +59654,7 @@ func (x *DeleteOperatingSystemResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteOperatingSystemResponse.ProtoReflect.Descriptor instead. func (*DeleteOperatingSystemResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{846} + return file_nico_nico_proto_rawDescGZIP(), []int{848} } type OperatingSystemSearchFilter struct { @@ -59575,7 +59666,7 @@ type OperatingSystemSearchFilter struct { func (x *OperatingSystemSearchFilter) Reset() { *x = OperatingSystemSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[847] + mi := &file_nico_nico_proto_msgTypes[849] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59587,7 +59678,7 @@ func (x *OperatingSystemSearchFilter) String() string { func (*OperatingSystemSearchFilter) ProtoMessage() {} func (x *OperatingSystemSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[847] + mi := &file_nico_nico_proto_msgTypes[849] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59600,7 +59691,7 @@ func (x *OperatingSystemSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatingSystemSearchFilter.ProtoReflect.Descriptor instead. func (*OperatingSystemSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{847} + return file_nico_nico_proto_rawDescGZIP(), []int{849} } func (x *OperatingSystemSearchFilter) GetTenantOrganizationId() string { @@ -59619,7 +59710,7 @@ type OperatingSystemIdList struct { func (x *OperatingSystemIdList) Reset() { *x = OperatingSystemIdList{} - mi := &file_nico_nico_proto_msgTypes[848] + mi := &file_nico_nico_proto_msgTypes[850] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59631,7 +59722,7 @@ func (x *OperatingSystemIdList) String() string { func (*OperatingSystemIdList) ProtoMessage() {} func (x *OperatingSystemIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[848] + mi := &file_nico_nico_proto_msgTypes[850] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59644,7 +59735,7 @@ func (x *OperatingSystemIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatingSystemIdList.ProtoReflect.Descriptor instead. func (*OperatingSystemIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{848} + return file_nico_nico_proto_rawDescGZIP(), []int{850} } func (x *OperatingSystemIdList) GetIds() []*OperatingSystemId { @@ -59663,7 +59754,7 @@ type OperatingSystemsByIdsRequest struct { func (x *OperatingSystemsByIdsRequest) Reset() { *x = OperatingSystemsByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[849] + mi := &file_nico_nico_proto_msgTypes[851] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59675,7 +59766,7 @@ func (x *OperatingSystemsByIdsRequest) String() string { func (*OperatingSystemsByIdsRequest) ProtoMessage() {} func (x *OperatingSystemsByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[849] + mi := &file_nico_nico_proto_msgTypes[851] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59688,7 +59779,7 @@ func (x *OperatingSystemsByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatingSystemsByIdsRequest.ProtoReflect.Descriptor instead. func (*OperatingSystemsByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{849} + return file_nico_nico_proto_rawDescGZIP(), []int{851} } func (x *OperatingSystemsByIdsRequest) GetIds() []*OperatingSystemId { @@ -59707,7 +59798,7 @@ type OperatingSystemList struct { func (x *OperatingSystemList) Reset() { *x = OperatingSystemList{} - mi := &file_nico_nico_proto_msgTypes[850] + mi := &file_nico_nico_proto_msgTypes[852] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59719,7 +59810,7 @@ func (x *OperatingSystemList) String() string { func (*OperatingSystemList) ProtoMessage() {} func (x *OperatingSystemList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[850] + mi := &file_nico_nico_proto_msgTypes[852] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59732,7 +59823,7 @@ func (x *OperatingSystemList) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatingSystemList.ProtoReflect.Descriptor instead. func (*OperatingSystemList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{850} + return file_nico_nico_proto_rawDescGZIP(), []int{852} } func (x *OperatingSystemList) GetOperatingSystems() []*OperatingSystem { @@ -59751,7 +59842,7 @@ type GetOperatingSystemCachableIpxeTemplateArtifactsRequest struct { func (x *GetOperatingSystemCachableIpxeTemplateArtifactsRequest) Reset() { *x = GetOperatingSystemCachableIpxeTemplateArtifactsRequest{} - mi := &file_nico_nico_proto_msgTypes[851] + mi := &file_nico_nico_proto_msgTypes[853] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59763,7 +59854,7 @@ func (x *GetOperatingSystemCachableIpxeTemplateArtifactsRequest) String() string func (*GetOperatingSystemCachableIpxeTemplateArtifactsRequest) ProtoMessage() {} func (x *GetOperatingSystemCachableIpxeTemplateArtifactsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[851] + mi := &file_nico_nico_proto_msgTypes[853] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59776,7 +59867,7 @@ func (x *GetOperatingSystemCachableIpxeTemplateArtifactsRequest) ProtoReflect() // Deprecated: Use GetOperatingSystemCachableIpxeTemplateArtifactsRequest.ProtoReflect.Descriptor instead. func (*GetOperatingSystemCachableIpxeTemplateArtifactsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{851} + return file_nico_nico_proto_rawDescGZIP(), []int{853} } func (x *GetOperatingSystemCachableIpxeTemplateArtifactsRequest) GetId() *OperatingSystemId { @@ -59795,7 +59886,7 @@ type IpxeTemplateArtifactList struct { func (x *IpxeTemplateArtifactList) Reset() { *x = IpxeTemplateArtifactList{} - mi := &file_nico_nico_proto_msgTypes[852] + mi := &file_nico_nico_proto_msgTypes[854] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59807,7 +59898,7 @@ func (x *IpxeTemplateArtifactList) String() string { func (*IpxeTemplateArtifactList) ProtoMessage() {} func (x *IpxeTemplateArtifactList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[852] + mi := &file_nico_nico_proto_msgTypes[854] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59820,7 +59911,7 @@ func (x *IpxeTemplateArtifactList) ProtoReflect() protoreflect.Message { // Deprecated: Use IpxeTemplateArtifactList.ProtoReflect.Descriptor instead. func (*IpxeTemplateArtifactList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{852} + return file_nico_nico_proto_rawDescGZIP(), []int{854} } func (x *IpxeTemplateArtifactList) GetArtifacts() []*IpxeTemplateArtifact { @@ -59842,7 +59933,7 @@ type IpxeTemplateArtifactUpdateRequest struct { func (x *IpxeTemplateArtifactUpdateRequest) Reset() { *x = IpxeTemplateArtifactUpdateRequest{} - mi := &file_nico_nico_proto_msgTypes[853] + mi := &file_nico_nico_proto_msgTypes[855] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59854,7 +59945,7 @@ func (x *IpxeTemplateArtifactUpdateRequest) String() string { func (*IpxeTemplateArtifactUpdateRequest) ProtoMessage() {} func (x *IpxeTemplateArtifactUpdateRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[853] + mi := &file_nico_nico_proto_msgTypes[855] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59867,7 +59958,7 @@ func (x *IpxeTemplateArtifactUpdateRequest) ProtoReflect() protoreflect.Message // Deprecated: Use IpxeTemplateArtifactUpdateRequest.ProtoReflect.Descriptor instead. func (*IpxeTemplateArtifactUpdateRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{853} + return file_nico_nico_proto_rawDescGZIP(), []int{855} } func (x *IpxeTemplateArtifactUpdateRequest) GetName() string { @@ -59894,7 +59985,7 @@ type UpdateOperatingSystemIpxeTemplateArtifactRequest struct { func (x *UpdateOperatingSystemIpxeTemplateArtifactRequest) Reset() { *x = UpdateOperatingSystemIpxeTemplateArtifactRequest{} - mi := &file_nico_nico_proto_msgTypes[854] + mi := &file_nico_nico_proto_msgTypes[856] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59906,7 +59997,7 @@ func (x *UpdateOperatingSystemIpxeTemplateArtifactRequest) String() string { func (*UpdateOperatingSystemIpxeTemplateArtifactRequest) ProtoMessage() {} func (x *UpdateOperatingSystemIpxeTemplateArtifactRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[854] + mi := &file_nico_nico_proto_msgTypes[856] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59919,7 +60010,7 @@ func (x *UpdateOperatingSystemIpxeTemplateArtifactRequest) ProtoReflect() protor // Deprecated: Use UpdateOperatingSystemIpxeTemplateArtifactRequest.ProtoReflect.Descriptor instead. func (*UpdateOperatingSystemIpxeTemplateArtifactRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{854} + return file_nico_nico_proto_rawDescGZIP(), []int{856} } func (x *UpdateOperatingSystemIpxeTemplateArtifactRequest) GetId() *OperatingSystemId { @@ -59946,7 +60037,7 @@ type HostRepresentorInterceptBridging struct { func (x *HostRepresentorInterceptBridging) Reset() { *x = HostRepresentorInterceptBridging{} - mi := &file_nico_nico_proto_msgTypes[855] + mi := &file_nico_nico_proto_msgTypes[857] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -59958,7 +60049,7 @@ func (x *HostRepresentorInterceptBridging) String() string { func (*HostRepresentorInterceptBridging) ProtoMessage() {} func (x *HostRepresentorInterceptBridging) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[855] + mi := &file_nico_nico_proto_msgTypes[857] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -59971,7 +60062,7 @@ func (x *HostRepresentorInterceptBridging) ProtoReflect() protoreflect.Message { // Deprecated: Use HostRepresentorInterceptBridging.ProtoReflect.Descriptor instead. func (*HostRepresentorInterceptBridging) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{855} + return file_nico_nico_proto_rawDescGZIP(), []int{857} } func (x *HostRepresentorInterceptBridging) GetBridge() string { @@ -60002,7 +60093,7 @@ type ReWrapSecretsRequest struct { func (x *ReWrapSecretsRequest) Reset() { *x = ReWrapSecretsRequest{} - mi := &file_nico_nico_proto_msgTypes[856] + mi := &file_nico_nico_proto_msgTypes[858] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60014,7 +60105,7 @@ func (x *ReWrapSecretsRequest) String() string { func (*ReWrapSecretsRequest) ProtoMessage() {} func (x *ReWrapSecretsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[856] + mi := &file_nico_nico_proto_msgTypes[858] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60027,7 +60118,7 @@ func (x *ReWrapSecretsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReWrapSecretsRequest.ProtoReflect.Descriptor instead. func (*ReWrapSecretsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{856} + return file_nico_nico_proto_rawDescGZIP(), []int{858} } func (x *ReWrapSecretsRequest) GetBatchSize() uint32 { @@ -60054,7 +60145,7 @@ type ReWrapSecretsResponse struct { func (x *ReWrapSecretsResponse) Reset() { *x = ReWrapSecretsResponse{} - mi := &file_nico_nico_proto_msgTypes[857] + mi := &file_nico_nico_proto_msgTypes[859] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60066,7 +60157,7 @@ func (x *ReWrapSecretsResponse) String() string { func (*ReWrapSecretsResponse) ProtoMessage() {} func (x *ReWrapSecretsResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[857] + mi := &file_nico_nico_proto_msgTypes[859] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60079,7 +60170,7 @@ func (x *ReWrapSecretsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReWrapSecretsResponse.ProtoReflect.Descriptor instead. func (*ReWrapSecretsResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{857} + return file_nico_nico_proto_rawDescGZIP(), []int{859} } func (x *ReWrapSecretsResponse) GetReWrapped() uint64 { @@ -60112,7 +60203,7 @@ type GetMachineBootInterfacesRequest struct { func (x *GetMachineBootInterfacesRequest) Reset() { *x = GetMachineBootInterfacesRequest{} - mi := &file_nico_nico_proto_msgTypes[858] + mi := &file_nico_nico_proto_msgTypes[860] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60124,7 +60215,7 @@ func (x *GetMachineBootInterfacesRequest) String() string { func (*GetMachineBootInterfacesRequest) ProtoMessage() {} func (x *GetMachineBootInterfacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[858] + mi := &file_nico_nico_proto_msgTypes[860] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60137,7 +60228,7 @@ func (x *GetMachineBootInterfacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetMachineBootInterfacesRequest.ProtoReflect.Descriptor instead. func (*GetMachineBootInterfacesRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{858} + return file_nico_nico_proto_rawDescGZIP(), []int{860} } func (x *GetMachineBootInterfacesRequest) GetMachineId() *MachineId { @@ -60162,7 +60253,7 @@ type MachineBootInterface struct { func (x *MachineBootInterface) Reset() { *x = MachineBootInterface{} - mi := &file_nico_nico_proto_msgTypes[859] + mi := &file_nico_nico_proto_msgTypes[861] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60174,7 +60265,7 @@ func (x *MachineBootInterface) String() string { func (*MachineBootInterface) ProtoMessage() {} func (x *MachineBootInterface) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[859] + mi := &file_nico_nico_proto_msgTypes[861] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60187,7 +60278,7 @@ func (x *MachineBootInterface) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineBootInterface.ProtoReflect.Descriptor instead. func (*MachineBootInterface) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{859} + return file_nico_nico_proto_rawDescGZIP(), []int{861} } func (x *MachineBootInterface) GetMacAddress() string { @@ -60225,7 +60316,7 @@ type MachineInterfaceBootInterface struct { func (x *MachineInterfaceBootInterface) Reset() { *x = MachineInterfaceBootInterface{} - mi := &file_nico_nico_proto_msgTypes[860] + mi := &file_nico_nico_proto_msgTypes[862] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60237,7 +60328,7 @@ func (x *MachineInterfaceBootInterface) String() string { func (*MachineInterfaceBootInterface) ProtoMessage() {} func (x *MachineInterfaceBootInterface) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[860] + mi := &file_nico_nico_proto_msgTypes[862] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60250,7 +60341,7 @@ func (x *MachineInterfaceBootInterface) ProtoReflect() protoreflect.Message { // Deprecated: Use MachineInterfaceBootInterface.ProtoReflect.Descriptor instead. func (*MachineInterfaceBootInterface) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{860} + return file_nico_nico_proto_rawDescGZIP(), []int{862} } func (x *MachineInterfaceBootInterface) GetMacAddress() string { @@ -60303,7 +60394,7 @@ type PredictedBootInterface struct { func (x *PredictedBootInterface) Reset() { *x = PredictedBootInterface{} - mi := &file_nico_nico_proto_msgTypes[861] + mi := &file_nico_nico_proto_msgTypes[863] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60315,7 +60406,7 @@ func (x *PredictedBootInterface) String() string { func (*PredictedBootInterface) ProtoMessage() {} func (x *PredictedBootInterface) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[861] + mi := &file_nico_nico_proto_msgTypes[863] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60328,7 +60419,7 @@ func (x *PredictedBootInterface) ProtoReflect() protoreflect.Message { // Deprecated: Use PredictedBootInterface.ProtoReflect.Descriptor instead. func (*PredictedBootInterface) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{861} + return file_nico_nico_proto_rawDescGZIP(), []int{863} } func (x *PredictedBootInterface) GetMacAddress() string { @@ -60373,7 +60464,7 @@ type ExploredBootInterface struct { func (x *ExploredBootInterface) Reset() { *x = ExploredBootInterface{} - mi := &file_nico_nico_proto_msgTypes[862] + mi := &file_nico_nico_proto_msgTypes[864] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60385,7 +60476,7 @@ func (x *ExploredBootInterface) String() string { func (*ExploredBootInterface) ProtoMessage() {} func (x *ExploredBootInterface) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[862] + mi := &file_nico_nico_proto_msgTypes[864] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60398,7 +60489,7 @@ func (x *ExploredBootInterface) ProtoReflect() protoreflect.Message { // Deprecated: Use ExploredBootInterface.ProtoReflect.Descriptor instead. func (*ExploredBootInterface) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{862} + return file_nico_nico_proto_rawDescGZIP(), []int{864} } func (x *ExploredBootInterface) GetAddress() string { @@ -60436,7 +60527,7 @@ type RetainedBootInterface struct { func (x *RetainedBootInterface) Reset() { *x = RetainedBootInterface{} - mi := &file_nico_nico_proto_msgTypes[863] + mi := &file_nico_nico_proto_msgTypes[865] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60448,7 +60539,7 @@ func (x *RetainedBootInterface) String() string { func (*RetainedBootInterface) ProtoMessage() {} func (x *RetainedBootInterface) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[863] + mi := &file_nico_nico_proto_msgTypes[865] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60461,7 +60552,7 @@ func (x *RetainedBootInterface) ProtoReflect() protoreflect.Message { // Deprecated: Use RetainedBootInterface.ProtoReflect.Descriptor instead. func (*RetainedBootInterface) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{863} + return file_nico_nico_proto_rawDescGZIP(), []int{865} } func (x *RetainedBootInterface) GetMacAddress() string { @@ -60525,7 +60616,7 @@ type GetMachineBootInterfacesResponse struct { func (x *GetMachineBootInterfacesResponse) Reset() { *x = GetMachineBootInterfacesResponse{} - mi := &file_nico_nico_proto_msgTypes[864] + mi := &file_nico_nico_proto_msgTypes[866] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60537,7 +60628,7 @@ func (x *GetMachineBootInterfacesResponse) String() string { func (*GetMachineBootInterfacesResponse) ProtoMessage() {} func (x *GetMachineBootInterfacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[864] + mi := &file_nico_nico_proto_msgTypes[866] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60550,7 +60641,7 @@ func (x *GetMachineBootInterfacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetMachineBootInterfacesResponse.ProtoReflect.Descriptor instead. func (*GetMachineBootInterfacesResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{864} + return file_nico_nico_proto_rawDescGZIP(), []int{866} } func (x *GetMachineBootInterfacesResponse) GetMachineId() *MachineId { @@ -60639,7 +60730,7 @@ type GetContainerRegistryCredentialRequest struct { func (x *GetContainerRegistryCredentialRequest) Reset() { *x = GetContainerRegistryCredentialRequest{} - mi := &file_nico_nico_proto_msgTypes[865] + mi := &file_nico_nico_proto_msgTypes[867] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60651,7 +60742,7 @@ func (x *GetContainerRegistryCredentialRequest) String() string { func (*GetContainerRegistryCredentialRequest) ProtoMessage() {} func (x *GetContainerRegistryCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[865] + mi := &file_nico_nico_proto_msgTypes[867] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60664,7 +60755,7 @@ func (x *GetContainerRegistryCredentialRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use GetContainerRegistryCredentialRequest.ProtoReflect.Descriptor instead. func (*GetContainerRegistryCredentialRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{865} + return file_nico_nico_proto_rawDescGZIP(), []int{867} } func (x *GetContainerRegistryCredentialRequest) GetRegistry() string { @@ -60684,7 +60775,7 @@ type GetContainerRegistryCredentialResponse struct { func (x *GetContainerRegistryCredentialResponse) Reset() { *x = GetContainerRegistryCredentialResponse{} - mi := &file_nico_nico_proto_msgTypes[866] + mi := &file_nico_nico_proto_msgTypes[868] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60696,7 +60787,7 @@ func (x *GetContainerRegistryCredentialResponse) String() string { func (*GetContainerRegistryCredentialResponse) ProtoMessage() {} func (x *GetContainerRegistryCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[866] + mi := &file_nico_nico_proto_msgTypes[868] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60709,7 +60800,7 @@ func (x *GetContainerRegistryCredentialResponse) ProtoReflect() protoreflect.Mes // Deprecated: Use GetContainerRegistryCredentialResponse.ProtoReflect.Descriptor instead. func (*GetContainerRegistryCredentialResponse) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{866} + return file_nico_nico_proto_rawDescGZIP(), []int{868} } func (x *GetContainerRegistryCredentialResponse) GetUsername() string { @@ -60737,7 +60828,7 @@ type SetContainerRegistryCredentialRequest struct { func (x *SetContainerRegistryCredentialRequest) Reset() { *x = SetContainerRegistryCredentialRequest{} - mi := &file_nico_nico_proto_msgTypes[867] + mi := &file_nico_nico_proto_msgTypes[869] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60749,7 +60840,7 @@ func (x *SetContainerRegistryCredentialRequest) String() string { func (*SetContainerRegistryCredentialRequest) ProtoMessage() {} func (x *SetContainerRegistryCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[867] + mi := &file_nico_nico_proto_msgTypes[869] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60762,7 +60853,7 @@ func (x *SetContainerRegistryCredentialRequest) ProtoReflect() protoreflect.Mess // Deprecated: Use SetContainerRegistryCredentialRequest.ProtoReflect.Descriptor instead. func (*SetContainerRegistryCredentialRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{867} + return file_nico_nico_proto_rawDescGZIP(), []int{869} } func (x *SetContainerRegistryCredentialRequest) GetRegistry() string { @@ -60802,7 +60893,7 @@ type SitePrefix struct { func (x *SitePrefix) Reset() { *x = SitePrefix{} - mi := &file_nico_nico_proto_msgTypes[868] + mi := &file_nico_nico_proto_msgTypes[870] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60814,7 +60905,7 @@ func (x *SitePrefix) String() string { func (*SitePrefix) ProtoMessage() {} func (x *SitePrefix) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[868] + mi := &file_nico_nico_proto_msgTypes[870] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60827,7 +60918,7 @@ func (x *SitePrefix) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefix.ProtoReflect.Descriptor instead. func (*SitePrefix) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{868} + return file_nico_nico_proto_rawDescGZIP(), []int{870} } func (x *SitePrefix) GetId() *SitePrefixId { @@ -60892,7 +60983,7 @@ type SitePrefixConfig struct { func (x *SitePrefixConfig) Reset() { *x = SitePrefixConfig{} - mi := &file_nico_nico_proto_msgTypes[869] + mi := &file_nico_nico_proto_msgTypes[871] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60904,7 +60995,7 @@ func (x *SitePrefixConfig) String() string { func (*SitePrefixConfig) ProtoMessage() {} func (x *SitePrefixConfig) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[869] + mi := &file_nico_nico_proto_msgTypes[871] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60917,7 +61008,7 @@ func (x *SitePrefixConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefixConfig.ProtoReflect.Descriptor instead. func (*SitePrefixConfig) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{869} + return file_nico_nico_proto_rawDescGZIP(), []int{871} } func (x *SitePrefixConfig) GetPrefix() string { @@ -60951,7 +61042,7 @@ type SitePrefixStatus struct { func (x *SitePrefixStatus) Reset() { *x = SitePrefixStatus{} - mi := &file_nico_nico_proto_msgTypes[870] + mi := &file_nico_nico_proto_msgTypes[872] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -60963,7 +61054,7 @@ func (x *SitePrefixStatus) String() string { func (*SitePrefixStatus) ProtoMessage() {} func (x *SitePrefixStatus) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[870] + mi := &file_nico_nico_proto_msgTypes[872] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -60976,7 +61067,7 @@ func (x *SitePrefixStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefixStatus.ProtoReflect.Descriptor instead. func (*SitePrefixStatus) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{870} + return file_nico_nico_proto_rawDescGZIP(), []int{872} } func (x *SitePrefixStatus) GetAuthority() SitePrefixAuthority { @@ -61010,7 +61101,7 @@ type SitePrefixSearchFilter struct { func (x *SitePrefixSearchFilter) Reset() { *x = SitePrefixSearchFilter{} - mi := &file_nico_nico_proto_msgTypes[871] + mi := &file_nico_nico_proto_msgTypes[873] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61022,7 +61113,7 @@ func (x *SitePrefixSearchFilter) String() string { func (*SitePrefixSearchFilter) ProtoMessage() {} func (x *SitePrefixSearchFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[871] + mi := &file_nico_nico_proto_msgTypes[873] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61035,7 +61126,7 @@ func (x *SitePrefixSearchFilter) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefixSearchFilter.ProtoReflect.Descriptor instead. func (*SitePrefixSearchFilter) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{871} + return file_nico_nico_proto_rawDescGZIP(), []int{873} } func (x *SitePrefixSearchFilter) GetTenantOrganizationId() string { @@ -61089,7 +61180,7 @@ type SitePrefixesByIdsRequest struct { func (x *SitePrefixesByIdsRequest) Reset() { *x = SitePrefixesByIdsRequest{} - mi := &file_nico_nico_proto_msgTypes[872] + mi := &file_nico_nico_proto_msgTypes[874] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61101,7 +61192,7 @@ func (x *SitePrefixesByIdsRequest) String() string { func (*SitePrefixesByIdsRequest) ProtoMessage() {} func (x *SitePrefixesByIdsRequest) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[872] + mi := &file_nico_nico_proto_msgTypes[874] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61114,7 +61205,7 @@ func (x *SitePrefixesByIdsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefixesByIdsRequest.ProtoReflect.Descriptor instead. func (*SitePrefixesByIdsRequest) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{872} + return file_nico_nico_proto_rawDescGZIP(), []int{874} } func (x *SitePrefixesByIdsRequest) GetSitePrefixIds() []*SitePrefixId { @@ -61133,7 +61224,7 @@ type SitePrefixIdList struct { func (x *SitePrefixIdList) Reset() { *x = SitePrefixIdList{} - mi := &file_nico_nico_proto_msgTypes[873] + mi := &file_nico_nico_proto_msgTypes[875] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61145,7 +61236,7 @@ func (x *SitePrefixIdList) String() string { func (*SitePrefixIdList) ProtoMessage() {} func (x *SitePrefixIdList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[873] + mi := &file_nico_nico_proto_msgTypes[875] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61158,7 +61249,7 @@ func (x *SitePrefixIdList) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefixIdList.ProtoReflect.Descriptor instead. func (*SitePrefixIdList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{873} + return file_nico_nico_proto_rawDescGZIP(), []int{875} } func (x *SitePrefixIdList) GetSitePrefixIds() []*SitePrefixId { @@ -61177,7 +61268,7 @@ type SitePrefixList struct { func (x *SitePrefixList) Reset() { *x = SitePrefixList{} - mi := &file_nico_nico_proto_msgTypes[874] + mi := &file_nico_nico_proto_msgTypes[876] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61189,7 +61280,7 @@ func (x *SitePrefixList) String() string { func (*SitePrefixList) ProtoMessage() {} func (x *SitePrefixList) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[874] + mi := &file_nico_nico_proto_msgTypes[876] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61202,7 +61293,7 @@ func (x *SitePrefixList) ProtoReflect() protoreflect.Message { // Deprecated: Use SitePrefixList.ProtoReflect.Descriptor instead. func (*SitePrefixList) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{874} + return file_nico_nico_proto_rawDescGZIP(), []int{876} } func (x *SitePrefixList) GetSitePrefixes() []*SitePrefix { @@ -61223,7 +61314,7 @@ type DNSMessage_DNSQuestion struct { func (x *DNSMessage_DNSQuestion) Reset() { *x = DNSMessage_DNSQuestion{} - mi := &file_nico_nico_proto_msgTypes[876] + mi := &file_nico_nico_proto_msgTypes[878] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61235,7 +61326,7 @@ func (x *DNSMessage_DNSQuestion) String() string { func (*DNSMessage_DNSQuestion) ProtoMessage() {} func (x *DNSMessage_DNSQuestion) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[876] + mi := &file_nico_nico_proto_msgTypes[878] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61281,7 +61372,7 @@ type DNSMessage_DNSResponse struct { func (x *DNSMessage_DNSResponse) Reset() { *x = DNSMessage_DNSResponse{} - mi := &file_nico_nico_proto_msgTypes[877] + mi := &file_nico_nico_proto_msgTypes[879] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61293,7 +61384,7 @@ func (x *DNSMessage_DNSResponse) String() string { func (*DNSMessage_DNSResponse) ProtoMessage() {} func (x *DNSMessage_DNSResponse) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[877] + mi := &file_nico_nico_proto_msgTypes[879] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61325,7 +61416,7 @@ type DNSMessage_DNSResponse_DNSRR struct { func (x *DNSMessage_DNSResponse_DNSRR) Reset() { *x = DNSMessage_DNSResponse_DNSRR{} - mi := &file_nico_nico_proto_msgTypes[878] + mi := &file_nico_nico_proto_msgTypes[880] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61337,7 +61428,7 @@ func (x *DNSMessage_DNSResponse_DNSRR) String() string { func (*DNSMessage_DNSResponse_DNSRR) ProtoMessage() {} func (x *DNSMessage_DNSResponse_DNSRR) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[878] + mi := &file_nico_nico_proto_msgTypes[880] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61371,7 +61462,7 @@ type MachineCredentialsUpdateRequest_Credentials struct { func (x *MachineCredentialsUpdateRequest_Credentials) Reset() { *x = MachineCredentialsUpdateRequest_Credentials{} - mi := &file_nico_nico_proto_msgTypes[884] + mi := &file_nico_nico_proto_msgTypes[886] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61383,7 +61474,7 @@ func (x *MachineCredentialsUpdateRequest_Credentials) String() string { func (*MachineCredentialsUpdateRequest_Credentials) ProtoMessage() {} func (x *MachineCredentialsUpdateRequest_Credentials) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[884] + mi := &file_nico_nico_proto_msgTypes[886] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61430,7 +61521,7 @@ type ForgeAgentControlResponse_ForgeAgentControlExtraInfo struct { func (x *ForgeAgentControlResponse_ForgeAgentControlExtraInfo) Reset() { *x = ForgeAgentControlResponse_ForgeAgentControlExtraInfo{} - mi := &file_nico_nico_proto_msgTypes[885] + mi := &file_nico_nico_proto_msgTypes[887] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61442,7 +61533,7 @@ func (x *ForgeAgentControlResponse_ForgeAgentControlExtraInfo) String() string { func (*ForgeAgentControlResponse_ForgeAgentControlExtraInfo) ProtoMessage() {} func (x *ForgeAgentControlResponse_ForgeAgentControlExtraInfo) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[885] + mi := &file_nico_nico_proto_msgTypes[887] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61473,7 +61564,7 @@ type ForgeAgentControlResponse_Noop struct { func (x *ForgeAgentControlResponse_Noop) Reset() { *x = ForgeAgentControlResponse_Noop{} - mi := &file_nico_nico_proto_msgTypes[886] + mi := &file_nico_nico_proto_msgTypes[888] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61485,7 +61576,7 @@ func (x *ForgeAgentControlResponse_Noop) String() string { func (*ForgeAgentControlResponse_Noop) ProtoMessage() {} func (x *ForgeAgentControlResponse_Noop) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[886] + mi := &file_nico_nico_proto_msgTypes[888] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61509,7 +61600,7 @@ type ForgeAgentControlResponse_Reset struct { func (x *ForgeAgentControlResponse_Reset) Reset() { *x = ForgeAgentControlResponse_Reset{} - mi := &file_nico_nico_proto_msgTypes[887] + mi := &file_nico_nico_proto_msgTypes[889] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61521,7 +61612,7 @@ func (x *ForgeAgentControlResponse_Reset) String() string { func (*ForgeAgentControlResponse_Reset) ProtoMessage() {} func (x *ForgeAgentControlResponse_Reset) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[887] + mi := &file_nico_nico_proto_msgTypes[889] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61545,7 +61636,7 @@ type ForgeAgentControlResponse_Discovery struct { func (x *ForgeAgentControlResponse_Discovery) Reset() { *x = ForgeAgentControlResponse_Discovery{} - mi := &file_nico_nico_proto_msgTypes[888] + mi := &file_nico_nico_proto_msgTypes[890] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61557,7 +61648,7 @@ func (x *ForgeAgentControlResponse_Discovery) String() string { func (*ForgeAgentControlResponse_Discovery) ProtoMessage() {} func (x *ForgeAgentControlResponse_Discovery) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[888] + mi := &file_nico_nico_proto_msgTypes[890] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61581,7 +61672,7 @@ type ForgeAgentControlResponse_Rebuild struct { func (x *ForgeAgentControlResponse_Rebuild) Reset() { *x = ForgeAgentControlResponse_Rebuild{} - mi := &file_nico_nico_proto_msgTypes[889] + mi := &file_nico_nico_proto_msgTypes[891] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61593,7 +61684,7 @@ func (x *ForgeAgentControlResponse_Rebuild) String() string { func (*ForgeAgentControlResponse_Rebuild) ProtoMessage() {} func (x *ForgeAgentControlResponse_Rebuild) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[889] + mi := &file_nico_nico_proto_msgTypes[891] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61617,7 +61708,7 @@ type ForgeAgentControlResponse_Retry struct { func (x *ForgeAgentControlResponse_Retry) Reset() { *x = ForgeAgentControlResponse_Retry{} - mi := &file_nico_nico_proto_msgTypes[890] + mi := &file_nico_nico_proto_msgTypes[892] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61629,7 +61720,7 @@ func (x *ForgeAgentControlResponse_Retry) String() string { func (*ForgeAgentControlResponse_Retry) ProtoMessage() {} func (x *ForgeAgentControlResponse_Retry) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[890] + mi := &file_nico_nico_proto_msgTypes[892] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61653,7 +61744,7 @@ type ForgeAgentControlResponse_Measure struct { func (x *ForgeAgentControlResponse_Measure) Reset() { *x = ForgeAgentControlResponse_Measure{} - mi := &file_nico_nico_proto_msgTypes[891] + mi := &file_nico_nico_proto_msgTypes[893] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61665,7 +61756,7 @@ func (x *ForgeAgentControlResponse_Measure) String() string { func (*ForgeAgentControlResponse_Measure) ProtoMessage() {} func (x *ForgeAgentControlResponse_Measure) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[891] + mi := &file_nico_nico_proto_msgTypes[893] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61689,7 +61780,7 @@ type ForgeAgentControlResponse_LogError struct { func (x *ForgeAgentControlResponse_LogError) Reset() { *x = ForgeAgentControlResponse_LogError{} - mi := &file_nico_nico_proto_msgTypes[892] + mi := &file_nico_nico_proto_msgTypes[894] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61701,7 +61792,7 @@ func (x *ForgeAgentControlResponse_LogError) String() string { func (*ForgeAgentControlResponse_LogError) ProtoMessage() {} func (x *ForgeAgentControlResponse_LogError) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[892] + mi := &file_nico_nico_proto_msgTypes[894] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61729,7 +61820,7 @@ type ForgeAgentControlResponse_MachineValidation struct { func (x *ForgeAgentControlResponse_MachineValidation) Reset() { *x = ForgeAgentControlResponse_MachineValidation{} - mi := &file_nico_nico_proto_msgTypes[893] + mi := &file_nico_nico_proto_msgTypes[895] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61741,7 +61832,7 @@ func (x *ForgeAgentControlResponse_MachineValidation) String() string { func (*ForgeAgentControlResponse_MachineValidation) ProtoMessage() {} func (x *ForgeAgentControlResponse_MachineValidation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[893] + mi := &file_nico_nico_proto_msgTypes[895] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61797,7 +61888,7 @@ type ForgeAgentControlResponse_MachineValidationFilter struct { func (x *ForgeAgentControlResponse_MachineValidationFilter) Reset() { *x = ForgeAgentControlResponse_MachineValidationFilter{} - mi := &file_nico_nico_proto_msgTypes[894] + mi := &file_nico_nico_proto_msgTypes[896] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61809,7 +61900,7 @@ func (x *ForgeAgentControlResponse_MachineValidationFilter) String() string { func (*ForgeAgentControlResponse_MachineValidationFilter) ProtoMessage() {} func (x *ForgeAgentControlResponse_MachineValidationFilter) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[894] + mi := &file_nico_nico_proto_msgTypes[896] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61862,7 +61953,7 @@ type ForgeAgentControlResponse_MlxAction struct { func (x *ForgeAgentControlResponse_MlxAction) Reset() { *x = ForgeAgentControlResponse_MlxAction{} - mi := &file_nico_nico_proto_msgTypes[895] + mi := &file_nico_nico_proto_msgTypes[897] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61874,7 +61965,7 @@ func (x *ForgeAgentControlResponse_MlxAction) String() string { func (*ForgeAgentControlResponse_MlxAction) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxAction) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[895] + mi := &file_nico_nico_proto_msgTypes[897] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -61914,7 +62005,7 @@ type ForgeAgentControlResponse_MlxDeviceAction struct { func (x *ForgeAgentControlResponse_MlxDeviceAction) Reset() { *x = ForgeAgentControlResponse_MlxDeviceAction{} - mi := &file_nico_nico_proto_msgTypes[896] + mi := &file_nico_nico_proto_msgTypes[898] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -61926,7 +62017,7 @@ func (x *ForgeAgentControlResponse_MlxDeviceAction) String() string { func (*ForgeAgentControlResponse_MlxDeviceAction) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxDeviceAction) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[896] + mi := &file_nico_nico_proto_msgTypes[898] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62048,7 +62139,7 @@ type ForgeAgentControlResponse_MlxDeviceNoop struct { func (x *ForgeAgentControlResponse_MlxDeviceNoop) Reset() { *x = ForgeAgentControlResponse_MlxDeviceNoop{} - mi := &file_nico_nico_proto_msgTypes[897] + mi := &file_nico_nico_proto_msgTypes[899] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62060,7 +62151,7 @@ func (x *ForgeAgentControlResponse_MlxDeviceNoop) String() string { func (*ForgeAgentControlResponse_MlxDeviceNoop) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxDeviceNoop) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[897] + mi := &file_nico_nico_proto_msgTypes[899] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62085,7 +62176,7 @@ type ForgeAgentControlResponse_MlxDeviceLock struct { func (x *ForgeAgentControlResponse_MlxDeviceLock) Reset() { *x = ForgeAgentControlResponse_MlxDeviceLock{} - mi := &file_nico_nico_proto_msgTypes[898] + mi := &file_nico_nico_proto_msgTypes[900] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62097,7 +62188,7 @@ func (x *ForgeAgentControlResponse_MlxDeviceLock) String() string { func (*ForgeAgentControlResponse_MlxDeviceLock) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxDeviceLock) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[898] + mi := &file_nico_nico_proto_msgTypes[900] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62129,7 +62220,7 @@ type ForgeAgentControlResponse_MlxDeviceUnlock struct { func (x *ForgeAgentControlResponse_MlxDeviceUnlock) Reset() { *x = ForgeAgentControlResponse_MlxDeviceUnlock{} - mi := &file_nico_nico_proto_msgTypes[899] + mi := &file_nico_nico_proto_msgTypes[901] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62141,7 +62232,7 @@ func (x *ForgeAgentControlResponse_MlxDeviceUnlock) String() string { func (*ForgeAgentControlResponse_MlxDeviceUnlock) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxDeviceUnlock) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[899] + mi := &file_nico_nico_proto_msgTypes[901] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62173,7 +62264,7 @@ type ForgeAgentControlResponse_MlxDeviceApplyProfile struct { func (x *ForgeAgentControlResponse_MlxDeviceApplyProfile) Reset() { *x = ForgeAgentControlResponse_MlxDeviceApplyProfile{} - mi := &file_nico_nico_proto_msgTypes[900] + mi := &file_nico_nico_proto_msgTypes[902] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62185,7 +62276,7 @@ func (x *ForgeAgentControlResponse_MlxDeviceApplyProfile) String() string { func (*ForgeAgentControlResponse_MlxDeviceApplyProfile) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxDeviceApplyProfile) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[900] + mi := &file_nico_nico_proto_msgTypes[902] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62217,7 +62308,7 @@ type ForgeAgentControlResponse_MlxDeviceApplyFirmware struct { func (x *ForgeAgentControlResponse_MlxDeviceApplyFirmware) Reset() { *x = ForgeAgentControlResponse_MlxDeviceApplyFirmware{} - mi := &file_nico_nico_proto_msgTypes[901] + mi := &file_nico_nico_proto_msgTypes[903] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62229,7 +62320,7 @@ func (x *ForgeAgentControlResponse_MlxDeviceApplyFirmware) String() string { func (*ForgeAgentControlResponse_MlxDeviceApplyFirmware) ProtoMessage() {} func (x *ForgeAgentControlResponse_MlxDeviceApplyFirmware) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[901] + mi := &file_nico_nico_proto_msgTypes[903] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62261,7 +62352,7 @@ type ForgeAgentControlResponse_FirmwareUpgrade struct { func (x *ForgeAgentControlResponse_FirmwareUpgrade) Reset() { *x = ForgeAgentControlResponse_FirmwareUpgrade{} - mi := &file_nico_nico_proto_msgTypes[902] + mi := &file_nico_nico_proto_msgTypes[904] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62273,7 +62364,7 @@ func (x *ForgeAgentControlResponse_FirmwareUpgrade) String() string { func (*ForgeAgentControlResponse_FirmwareUpgrade) ProtoMessage() {} func (x *ForgeAgentControlResponse_FirmwareUpgrade) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[902] + mi := &file_nico_nico_proto_msgTypes[904] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62306,7 +62397,7 @@ type ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair struct { func (x *ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair) Reset() { *x = ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair{} - mi := &file_nico_nico_proto_msgTypes[903] + mi := &file_nico_nico_proto_msgTypes[905] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62318,7 +62409,7 @@ func (x *ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair) Stri func (*ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair) ProtoMessage() {} func (x *ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[903] + mi := &file_nico_nico_proto_msgTypes[905] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62359,7 +62450,7 @@ type MachineCleanupInfo_CleanupStepResult struct { func (x *MachineCleanupInfo_CleanupStepResult) Reset() { *x = MachineCleanupInfo_CleanupStepResult{} - mi := &file_nico_nico_proto_msgTypes[904] + mi := &file_nico_nico_proto_msgTypes[906] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62371,7 +62462,7 @@ func (x *MachineCleanupInfo_CleanupStepResult) String() string { func (*MachineCleanupInfo_CleanupStepResult) ProtoMessage() {} func (x *MachineCleanupInfo_CleanupStepResult) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[904] + mi := &file_nico_nico_proto_msgTypes[906] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62416,7 +62507,7 @@ type DpuReprovisioningListResponse_DpuReprovisioningListItem struct { func (x *DpuReprovisioningListResponse_DpuReprovisioningListItem) Reset() { *x = DpuReprovisioningListResponse_DpuReprovisioningListItem{} - mi := &file_nico_nico_proto_msgTypes[905] + mi := &file_nico_nico_proto_msgTypes[907] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62428,7 +62519,7 @@ func (x *DpuReprovisioningListResponse_DpuReprovisioningListItem) String() strin func (*DpuReprovisioningListResponse_DpuReprovisioningListItem) ProtoMessage() {} func (x *DpuReprovisioningListResponse_DpuReprovisioningListItem) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[905] + mi := &file_nico_nico_proto_msgTypes[907] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62507,7 +62598,7 @@ type HostReprovisioningListResponse_HostReprovisioningListItem struct { func (x *HostReprovisioningListResponse_HostReprovisioningListItem) Reset() { *x = HostReprovisioningListResponse_HostReprovisioningListItem{} - mi := &file_nico_nico_proto_msgTypes[906] + mi := &file_nico_nico_proto_msgTypes[908] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62519,7 +62610,7 @@ func (x *HostReprovisioningListResponse_HostReprovisioningListItem) String() str func (*HostReprovisioningListResponse_HostReprovisioningListItem) ProtoMessage() {} func (x *HostReprovisioningListResponse_HostReprovisioningListItem) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[906] + mi := &file_nico_nico_proto_msgTypes[908] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62603,7 +62694,7 @@ type MachineValidationTestUpdateRequest_Payload struct { func (x *MachineValidationTestUpdateRequest_Payload) Reset() { *x = MachineValidationTestUpdateRequest_Payload{} - mi := &file_nico_nico_proto_msgTypes[907] + mi := &file_nico_nico_proto_msgTypes[909] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62615,7 +62706,7 @@ func (x *MachineValidationTestUpdateRequest_Payload) String() string { func (*MachineValidationTestUpdateRequest_Payload) ProtoMessage() {} func (x *MachineValidationTestUpdateRequest_Payload) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[907] + mi := &file_nico_nico_proto_msgTypes[909] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62628,7 +62719,7 @@ func (x *MachineValidationTestUpdateRequest_Payload) ProtoReflect() protoreflect // Deprecated: Use MachineValidationTestUpdateRequest_Payload.ProtoReflect.Descriptor instead. func (*MachineValidationTestUpdateRequest_Payload) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{528, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{530, 0} } func (x *MachineValidationTestUpdateRequest_Payload) GetName() string { @@ -62768,7 +62859,7 @@ type DPFStateResponse_DPFState struct { func (x *DPFStateResponse_DPFState) Reset() { *x = DPFStateResponse_DPFState{} - mi := &file_nico_nico_proto_msgTypes[913] + mi := &file_nico_nico_proto_msgTypes[915] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62780,7 +62871,7 @@ func (x *DPFStateResponse_DPFState) String() string { func (*DPFStateResponse_DPFState) ProtoMessage() {} func (x *DPFStateResponse_DPFState) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[913] + mi := &file_nico_nico_proto_msgTypes[915] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62793,7 +62884,7 @@ func (x *DPFStateResponse_DPFState) ProtoReflect() protoreflect.Message { // Deprecated: Use DPFStateResponse_DPFState.ProtoReflect.Descriptor instead. func (*DPFStateResponse_DPFState) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{798, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{800, 0} } func (x *DPFStateResponse_DPFState) GetMachineId() *MachineId { @@ -62850,7 +62941,7 @@ type GetMachineBootInterfacesResponse_Reconciliation struct { func (x *GetMachineBootInterfacesResponse_Reconciliation) Reset() { *x = GetMachineBootInterfacesResponse_Reconciliation{} - mi := &file_nico_nico_proto_msgTypes[914] + mi := &file_nico_nico_proto_msgTypes[916] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -62862,7 +62953,7 @@ func (x *GetMachineBootInterfacesResponse_Reconciliation) String() string { func (*GetMachineBootInterfacesResponse_Reconciliation) ProtoMessage() {} func (x *GetMachineBootInterfacesResponse_Reconciliation) ProtoReflect() protoreflect.Message { - mi := &file_nico_nico_proto_msgTypes[914] + mi := &file_nico_nico_proto_msgTypes[916] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -62875,7 +62966,7 @@ func (x *GetMachineBootInterfacesResponse_Reconciliation) ProtoReflect() protore // Deprecated: Use GetMachineBootInterfacesResponse_Reconciliation.ProtoReflect.Descriptor instead. func (*GetMachineBootInterfacesResponse_Reconciliation) Descriptor() ([]byte, []int) { - return file_nico_nico_proto_rawDescGZIP(), []int{864, 0} + return file_nico_nico_proto_rawDescGZIP(), []int{866, 0} } func (x *GetMachineBootInterfacesResponse_Reconciliation) GetDesiredBootInterface() *MachineBootInterface { @@ -65804,7 +65895,12 @@ const file_nico_nico_proto_rawDesc = "" + "\x0e_machine_query\"F\n" + "\x1dClearHostUefiPasswordResponse\x12\x1a\n" + "\x06job_id\x18\x01 \x01(\tH\x00R\x05jobId\x88\x01\x01B\t\n" + - "\a_job_id\"\xa3\x05\n" + + "\a_job_id\"\x81\x01\n" + + "\x19SetDpuUefiPasswordRequest\x12(\n" + + "\x06dpu_id\x18\x01 \x01(\v2\x11.common.MachineIdR\x05dpuId\x12(\n" + + "\rmachine_query\x18\x02 \x01(\tH\x00R\fmachineQuery\x88\x01\x01B\x10\n" + + "\x0e_machine_query\"\x1c\n" + + "\x1aSetDpuUefiPasswordResponse\"\xa3\x05\n" + "\x11OsImageAttributes\x12\x1c\n" + "\x02id\x18\x01 \x01(\v2\f.common.UUIDR\x02id\x12\x1d\n" + "\n" + @@ -68582,7 +68678,7 @@ const file_nico_nico_proto_rawDesc = "" + "(SITE_PREFIX_LIFECYCLE_STATE_PROVISIONING\x10\x01\x12%\n" + "!SITE_PREFIX_LIFECYCLE_STATE_READY\x10\x02\x12(\n" + "$SITE_PREFIX_LIFECYCLE_STATE_DELETING\x10\x03\x12%\n" + - "!SITE_PREFIX_LIFECYCLE_STATE_ERROR\x10\x042\xc3\xd6\x02\n" + + "!SITE_PREFIX_LIFECYCLE_STATE_ERROR\x10\x042\x9e\xd7\x02\n" + "\x05Forge\x122\n" + "\aVersion\x12\x15.forge.VersionRequest\x1a\x10.forge.BuildInfo\x125\n" + "\fCreateDomain\x12\x18.dns.CreateDomainRequest\x1a\v.dns.Domain\x125\n" + @@ -68781,7 +68877,8 @@ const file_nico_nico_proto_rawDesc = "" + "\x1cUpdateAgentReportedInventory\x12\x1e.forge.DpuAgentInventoryReport\x1a\x16.google.protobuf.Empty\x12}\n" + "\"UpdateInstancePhoneHomeLastContact\x12*.forge.InstancePhoneHomeLastContactRequest\x1a+.forge.InstancePhoneHomeLastContactResponse\x12\\\n" + "\x13SetHostUefiPassword\x12!.forge.SetHostUefiPasswordRequest\x1a\".forge.SetHostUefiPasswordResponse\x12b\n" + - "\x15ClearHostUefiPassword\x12#.forge.ClearHostUefiPasswordRequest\x1a$.forge.ClearHostUefiPasswordResponse\x12D\n" + + "\x15ClearHostUefiPassword\x12#.forge.ClearHostUefiPasswordRequest\x1a$.forge.ClearHostUefiPasswordResponse\x12Y\n" + + "\x12SetDpuUefiPassword\x12 .forge.SetDpuUefiPasswordRequest\x1a!.forge.SetDpuUefiPasswordResponse\x12D\n" + "\x12AddExpectedMachine\x12\x16.forge.ExpectedMachine\x1a\x16.google.protobuf.Empty\x12N\n" + "\x15DeleteExpectedMachine\x12\x1d.forge.ExpectedMachineRequest\x1a\x16.google.protobuf.Empty\x12G\n" + "\x15UpdateExpectedMachine\x12\x16.forge.ExpectedMachine\x1a\x16.google.protobuf.Empty\x12K\n" + @@ -69079,7 +69176,7 @@ func file_nico_nico_proto_rawDescGZIP() []byte { } var file_nico_nico_proto_enumTypes = make([]protoimpl.EnumInfo, 101) -var file_nico_nico_proto_msgTypes = make([]protoimpl.MessageInfo, 915) +var file_nico_nico_proto_msgTypes = make([]protoimpl.MessageInfo, 917) var file_nico_nico_proto_goTypes = []any{ (SpdmAttestationStatus)(0), // 0: forge.SpdmAttestationStatus (SpdmListAttestationMachinesRequestSelector)(0), // 1: forge.SpdmListAttestationMachinesRequestSelector @@ -69641,910 +69738,912 @@ var file_nico_nico_proto_goTypes = []any{ (*SetHostUefiPasswordResponse)(nil), // 557: forge.SetHostUefiPasswordResponse (*ClearHostUefiPasswordRequest)(nil), // 558: forge.ClearHostUefiPasswordRequest (*ClearHostUefiPasswordResponse)(nil), // 559: forge.ClearHostUefiPasswordResponse - (*OsImageAttributes)(nil), // 560: forge.OsImageAttributes - (*OsImage)(nil), // 561: forge.OsImage - (*ListOsImageRequest)(nil), // 562: forge.ListOsImageRequest - (*ListOsImageResponse)(nil), // 563: forge.ListOsImageResponse - (*DeleteOsImageRequest)(nil), // 564: forge.DeleteOsImageRequest - (*DeleteOsImageResponse)(nil), // 565: forge.DeleteOsImageResponse - (*GetIpxeTemplateRequest)(nil), // 566: forge.GetIpxeTemplateRequest - (*ListIpxeTemplatesRequest)(nil), // 567: forge.ListIpxeTemplatesRequest - (*IpxeTemplateList)(nil), // 568: forge.IpxeTemplateList - (*ExpectedHostNic)(nil), // 569: forge.ExpectedHostNic - (*HostLifecycleProfile)(nil), // 570: forge.HostLifecycleProfile - (*ExpectedMachine)(nil), // 571: forge.ExpectedMachine - (*ExpectedMachineRequest)(nil), // 572: forge.ExpectedMachineRequest - (*ExpectedMachineList)(nil), // 573: forge.ExpectedMachineList - (*LinkedExpectedMachineList)(nil), // 574: forge.LinkedExpectedMachineList - (*LinkedExpectedMachine)(nil), // 575: forge.LinkedExpectedMachine - (*UnexpectedMachineList)(nil), // 576: forge.UnexpectedMachineList - (*UnexpectedMachine)(nil), // 577: forge.UnexpectedMachine - (*BatchExpectedMachineOperationRequest)(nil), // 578: forge.BatchExpectedMachineOperationRequest - (*ExpectedMachineOperationResult)(nil), // 579: forge.ExpectedMachineOperationResult - (*BatchExpectedMachineOperationResponse)(nil), // 580: forge.BatchExpectedMachineOperationResponse - (*MachineRebootCompletedResponse)(nil), // 581: forge.MachineRebootCompletedResponse - (*MachineRebootCompletedRequest)(nil), // 582: forge.MachineRebootCompletedRequest - (*ScoutFirmwareUpgradeStatusRequest)(nil), // 583: forge.ScoutFirmwareUpgradeStatusRequest - (*MachineValidationCompletedRequest)(nil), // 584: forge.MachineValidationCompletedRequest - (*MachineValidationCompletedResponse)(nil), // 585: forge.MachineValidationCompletedResponse - (*MachineValidationResult)(nil), // 586: forge.MachineValidationResult - (*MachineValidationResultPostRequest)(nil), // 587: forge.MachineValidationResultPostRequest - (*MachineValidationResultList)(nil), // 588: forge.MachineValidationResultList - (*MachineValidationGetRequest)(nil), // 589: forge.MachineValidationGetRequest - (*MachineValidationStatus)(nil), // 590: forge.MachineValidationStatus - (*MachineValidationRun)(nil), // 591: forge.MachineValidationRun - (*MachineSetAutoUpdateRequest)(nil), // 592: forge.MachineSetAutoUpdateRequest - (*MachineSetAutoUpdateResponse)(nil), // 593: forge.MachineSetAutoUpdateResponse - (*GetMachineValidationExternalConfigRequest)(nil), // 594: forge.GetMachineValidationExternalConfigRequest - (*MachineValidationExternalConfig)(nil), // 595: forge.MachineValidationExternalConfig - (*GetMachineValidationExternalConfigResponse)(nil), // 596: forge.GetMachineValidationExternalConfigResponse - (*GetMachineValidationExternalConfigsRequest)(nil), // 597: forge.GetMachineValidationExternalConfigsRequest - (*GetMachineValidationExternalConfigsResponse)(nil), // 598: forge.GetMachineValidationExternalConfigsResponse - (*AddUpdateMachineValidationExternalConfigRequest)(nil), // 599: forge.AddUpdateMachineValidationExternalConfigRequest - (*RemoveMachineValidationExternalConfigRequest)(nil), // 600: forge.RemoveMachineValidationExternalConfigRequest - (*MachineValidationOnDemandRequest)(nil), // 601: forge.MachineValidationOnDemandRequest - (*MachineValidationOnDemandResponse)(nil), // 602: forge.MachineValidationOnDemandResponse - (*FirmwareUpgradeActivity)(nil), // 603: forge.FirmwareUpgradeActivity - (*NvosUpdateActivity)(nil), // 604: forge.NvosUpdateActivity - (*ConfigureNmxClusterActivity)(nil), // 605: forge.ConfigureNmxClusterActivity - (*PowerSequenceActivity)(nil), // 606: forge.PowerSequenceActivity - (*MaintenanceActivityConfig)(nil), // 607: forge.MaintenanceActivityConfig - (*RackMaintenanceScope)(nil), // 608: forge.RackMaintenanceScope - (*RackMaintenanceOnDemandRequest)(nil), // 609: forge.RackMaintenanceOnDemandRequest - (*RackMaintenanceOnDemandResponse)(nil), // 610: forge.RackMaintenanceOnDemandResponse - (*AdminPowerControlRequest)(nil), // 611: forge.AdminPowerControlRequest - (*AdminPowerControlResponse)(nil), // 612: forge.AdminPowerControlResponse - (*GetRedfishJobStateRequest)(nil), // 613: forge.GetRedfishJobStateRequest - (*GetRedfishJobStateResponse)(nil), // 614: forge.GetRedfishJobStateResponse - (*MachineValidationRunList)(nil), // 615: forge.MachineValidationRunList - (*MachineValidationRunListGetRequest)(nil), // 616: forge.MachineValidationRunListGetRequest - (*MachineValidationRunItemSearchFilter)(nil), // 617: forge.MachineValidationRunItemSearchFilter - (*MachineValidationRunItemIdList)(nil), // 618: forge.MachineValidationRunItemIdList - (*MachineValidationRunItemsByIdsRequest)(nil), // 619: forge.MachineValidationRunItemsByIdsRequest - (*MachineValidationRunItemList)(nil), // 620: forge.MachineValidationRunItemList - (*MachineValidationRunItem)(nil), // 621: forge.MachineValidationRunItem - (*MachineValidationAttemptGetRequest)(nil), // 622: forge.MachineValidationAttemptGetRequest - (*MachineValidationAttempt)(nil), // 623: forge.MachineValidationAttempt - (*MachineValidationHeartbeatRequest)(nil), // 624: forge.MachineValidationHeartbeatRequest - (*MachineValidationHeartbeatResponse)(nil), // 625: forge.MachineValidationHeartbeatResponse - (*IsBmcInManagedHostResponse)(nil), // 626: forge.IsBmcInManagedHostResponse - (*BmcCredentialStatusResponse)(nil), // 627: forge.BmcCredentialStatusResponse - (*MachineValidationTestsGetRequest)(nil), // 628: forge.MachineValidationTestsGetRequest - (*MachineValidationTestUpdateRequest)(nil), // 629: forge.MachineValidationTestUpdateRequest - (*MachineValidationTestAddRequest)(nil), // 630: forge.MachineValidationTestAddRequest - (*MachineValidationTestAddUpdateResponse)(nil), // 631: forge.MachineValidationTestAddUpdateResponse - (*MachineValidationTestsGetResponse)(nil), // 632: forge.MachineValidationTestsGetResponse - (*MachineValidationTestVerfiedRequest)(nil), // 633: forge.MachineValidationTestVerfiedRequest - (*MachineValidationTestVerfiedResponse)(nil), // 634: forge.MachineValidationTestVerfiedResponse - (*MachineValidationTest)(nil), // 635: forge.MachineValidationTest - (*MachineValidationTestNextVersionResponse)(nil), // 636: forge.MachineValidationTestNextVersionResponse - (*MachineValidationTestNextVersionRequest)(nil), // 637: forge.MachineValidationTestNextVersionRequest - (*MachineValidationTestEnableDisableTestRequest)(nil), // 638: forge.MachineValidationTestEnableDisableTestRequest - (*MachineValidationTestEnableDisableTestResponse)(nil), // 639: forge.MachineValidationTestEnableDisableTestResponse - (*MachineValidationRunRequest)(nil), // 640: forge.MachineValidationRunRequest - (*MachineValidationRunResponse)(nil), // 641: forge.MachineValidationRunResponse - (*MachineCapabilityAttributesCpu)(nil), // 642: forge.MachineCapabilityAttributesCpu - (*MachineCapabilityAttributesGpu)(nil), // 643: forge.MachineCapabilityAttributesGpu - (*MachineCapabilityAttributesMemory)(nil), // 644: forge.MachineCapabilityAttributesMemory - (*MachineCapabilityAttributesStorage)(nil), // 645: forge.MachineCapabilityAttributesStorage - (*MachineCapabilityAttributesNetwork)(nil), // 646: forge.MachineCapabilityAttributesNetwork - (*MachineCapabilityAttributesInfiniband)(nil), // 647: forge.MachineCapabilityAttributesInfiniband - (*MachineCapabilityAttributesDpu)(nil), // 648: forge.MachineCapabilityAttributesDpu - (*MachineCapabilitiesSet)(nil), // 649: forge.MachineCapabilitiesSet - (*InstanceTypeAttributes)(nil), // 650: forge.InstanceTypeAttributes - (*InstanceType)(nil), // 651: forge.InstanceType - (*InstanceTypeMachineCapabilityFilterAttributes)(nil), // 652: forge.InstanceTypeMachineCapabilityFilterAttributes - (*CreateInstanceTypeRequest)(nil), // 653: forge.CreateInstanceTypeRequest - (*CreateInstanceTypeResponse)(nil), // 654: forge.CreateInstanceTypeResponse - (*FindInstanceTypeIdsRequest)(nil), // 655: forge.FindInstanceTypeIdsRequest - (*FindInstanceTypeIdsResponse)(nil), // 656: forge.FindInstanceTypeIdsResponse - (*FindInstanceTypesByIdsRequest)(nil), // 657: forge.FindInstanceTypesByIdsRequest - (*FindInstanceTypesByIdsResponse)(nil), // 658: forge.FindInstanceTypesByIdsResponse - (*DeleteInstanceTypeRequest)(nil), // 659: forge.DeleteInstanceTypeRequest - (*DeleteInstanceTypeResponse)(nil), // 660: forge.DeleteInstanceTypeResponse - (*UpdateInstanceTypeResponse)(nil), // 661: forge.UpdateInstanceTypeResponse - (*UpdateInstanceTypeRequest)(nil), // 662: forge.UpdateInstanceTypeRequest - (*AssociateMachinesWithInstanceTypeRequest)(nil), // 663: forge.AssociateMachinesWithInstanceTypeRequest - (*AssociateMachinesWithInstanceTypeResponse)(nil), // 664: forge.AssociateMachinesWithInstanceTypeResponse - (*RemoveMachineInstanceTypeAssociationRequest)(nil), // 665: forge.RemoveMachineInstanceTypeAssociationRequest - (*RemoveMachineInstanceTypeAssociationResponse)(nil), // 666: forge.RemoveMachineInstanceTypeAssociationResponse - (*RedfishBrowseRequest)(nil), // 667: forge.RedfishBrowseRequest - (*RedfishBrowseResponse)(nil), // 668: forge.RedfishBrowseResponse - (*RedfishListActionsRequest)(nil), // 669: forge.RedfishListActionsRequest - (*RedfishListActionsResponse)(nil), // 670: forge.RedfishListActionsResponse - (*RedfishAction)(nil), // 671: forge.RedfishAction - (*OptionalRedfishActionResult)(nil), // 672: forge.OptionalRedfishActionResult - (*RedfishActionResult)(nil), // 673: forge.RedfishActionResult - (*RedfishCreateActionRequest)(nil), // 674: forge.RedfishCreateActionRequest - (*RedfishCreateActionResponse)(nil), // 675: forge.RedfishCreateActionResponse - (*RedfishActionID)(nil), // 676: forge.RedfishActionID - (*RedfishApproveActionResponse)(nil), // 677: forge.RedfishApproveActionResponse - (*RedfishApplyActionResponse)(nil), // 678: forge.RedfishApplyActionResponse - (*RedfishCancelActionResponse)(nil), // 679: forge.RedfishCancelActionResponse - (*UfmBrowseRequest)(nil), // 680: forge.UfmBrowseRequest - (*UfmBrowseResponse)(nil), // 681: forge.UfmBrowseResponse - (*NetworkSecurityGroupAttributes)(nil), // 682: forge.NetworkSecurityGroupAttributes - (*NetworkSecurityGroup)(nil), // 683: forge.NetworkSecurityGroup - (*CreateNetworkSecurityGroupRequest)(nil), // 684: forge.CreateNetworkSecurityGroupRequest - (*CreateNetworkSecurityGroupResponse)(nil), // 685: forge.CreateNetworkSecurityGroupResponse - (*FindNetworkSecurityGroupIdsRequest)(nil), // 686: forge.FindNetworkSecurityGroupIdsRequest - (*FindNetworkSecurityGroupIdsResponse)(nil), // 687: forge.FindNetworkSecurityGroupIdsResponse - (*FindNetworkSecurityGroupsByIdsRequest)(nil), // 688: forge.FindNetworkSecurityGroupsByIdsRequest - (*FindNetworkSecurityGroupsByIdsResponse)(nil), // 689: forge.FindNetworkSecurityGroupsByIdsResponse - (*UpdateNetworkSecurityGroupResponse)(nil), // 690: forge.UpdateNetworkSecurityGroupResponse - (*UpdateNetworkSecurityGroupRequest)(nil), // 691: forge.UpdateNetworkSecurityGroupRequest - (*DeleteNetworkSecurityGroupRequest)(nil), // 692: forge.DeleteNetworkSecurityGroupRequest - (*DeleteNetworkSecurityGroupResponse)(nil), // 693: forge.DeleteNetworkSecurityGroupResponse - (*NetworkSecurityGroupStatus)(nil), // 694: forge.NetworkSecurityGroupStatus - (*NetworkSecurityGroupPropagationObjectStatus)(nil), // 695: forge.NetworkSecurityGroupPropagationObjectStatus - (*GetNetworkSecurityGroupPropagationStatusResponse)(nil), // 696: forge.GetNetworkSecurityGroupPropagationStatusResponse - (*NetworkSecurityGroupIdList)(nil), // 697: forge.NetworkSecurityGroupIdList - (*GetNetworkSecurityGroupPropagationStatusRequest)(nil), // 698: forge.GetNetworkSecurityGroupPropagationStatusRequest - (*NetworkSecurityGroupRuleAttributes)(nil), // 699: forge.NetworkSecurityGroupRuleAttributes - (*ResolvedNetworkSecurityGroupRule)(nil), // 700: forge.ResolvedNetworkSecurityGroupRule - (*GetNetworkSecurityGroupAttachmentsRequest)(nil), // 701: forge.GetNetworkSecurityGroupAttachmentsRequest - (*NetworkSecurityGroupAttachments)(nil), // 702: forge.NetworkSecurityGroupAttachments - (*GetNetworkSecurityGroupAttachmentsResponse)(nil), // 703: forge.GetNetworkSecurityGroupAttachmentsResponse - (*GetDesiredFirmwareVersionsRequest)(nil), // 704: forge.GetDesiredFirmwareVersionsRequest - (*GetDesiredFirmwareVersionsResponse)(nil), // 705: forge.GetDesiredFirmwareVersionsResponse - (*DesiredFirmwareVersionEntry)(nil), // 706: forge.DesiredFirmwareVersionEntry - (*SkuComponentChassis)(nil), // 707: forge.SkuComponentChassis - (*SkuComponentCpu)(nil), // 708: forge.SkuComponentCpu - (*SkuComponentGpu)(nil), // 709: forge.SkuComponentGpu - (*SkuComponentEthernetDevices)(nil), // 710: forge.SkuComponentEthernetDevices - (*SkuComponentInfinibandDevices)(nil), // 711: forge.SkuComponentInfinibandDevices - (*SkuComponentStorage)(nil), // 712: forge.SkuComponentStorage - (*SkuComponentStorageController)(nil), // 713: forge.SkuComponentStorageController - (*SkuComponentMemory)(nil), // 714: forge.SkuComponentMemory - (*SkuComponentTpm)(nil), // 715: forge.SkuComponentTpm - (*SkuComponents)(nil), // 716: forge.SkuComponents - (*Sku)(nil), // 717: forge.Sku - (*SkuMachinePair)(nil), // 718: forge.SkuMachinePair - (*RemoveSkuRequest)(nil), // 719: forge.RemoveSkuRequest - (*SkuList)(nil), // 720: forge.SkuList - (*SkuIdList)(nil), // 721: forge.SkuIdList - (*SkuStatus)(nil), // 722: forge.SkuStatus - (*SkusByIdsRequest)(nil), // 723: forge.SkusByIdsRequest - (*SkuSearchFilter)(nil), // 724: forge.SkuSearchFilter - (*DpaInterface)(nil), // 725: forge.DpaInterface - (*DpaInterfaceCreationRequest)(nil), // 726: forge.DpaInterfaceCreationRequest - (*DpaInterfaceIdList)(nil), // 727: forge.DpaInterfaceIdList - (*DpaInterfacesByIdsRequest)(nil), // 728: forge.DpaInterfacesByIdsRequest - (*DpaInterfaceList)(nil), // 729: forge.DpaInterfaceList - (*DpaNetworkObservationSetRequest)(nil), // 730: forge.DpaNetworkObservationSetRequest - (*DpaInterfaceDeletionRequest)(nil), // 731: forge.DpaInterfaceDeletionRequest - (*DpaInterfaceDeletionResult)(nil), // 732: forge.DpaInterfaceDeletionResult - (*SkuUpdateMetadataRequest)(nil), // 733: forge.SkuUpdateMetadataRequest - (*PowerOptionRequest)(nil), // 734: forge.PowerOptionRequest - (*PowerOptionUpdateRequest)(nil), // 735: forge.PowerOptionUpdateRequest - (*PowerOptions)(nil), // 736: forge.PowerOptions - (*PowerOptionResponse)(nil), // 737: forge.PowerOptionResponse - (*ComputeAllocationAttributes)(nil), // 738: forge.ComputeAllocationAttributes - (*ComputeAllocation)(nil), // 739: forge.ComputeAllocation - (*CreateComputeAllocationRequest)(nil), // 740: forge.CreateComputeAllocationRequest - (*CreateComputeAllocationResponse)(nil), // 741: forge.CreateComputeAllocationResponse - (*FindComputeAllocationIdsRequest)(nil), // 742: forge.FindComputeAllocationIdsRequest - (*FindComputeAllocationIdsResponse)(nil), // 743: forge.FindComputeAllocationIdsResponse - (*FindComputeAllocationsByIdsRequest)(nil), // 744: forge.FindComputeAllocationsByIdsRequest - (*FindComputeAllocationsByIdsResponse)(nil), // 745: forge.FindComputeAllocationsByIdsResponse - (*UpdateComputeAllocationResponse)(nil), // 746: forge.UpdateComputeAllocationResponse - (*UpdateComputeAllocationRequest)(nil), // 747: forge.UpdateComputeAllocationRequest - (*DeleteComputeAllocationRequest)(nil), // 748: forge.DeleteComputeAllocationRequest - (*DeleteComputeAllocationResponse)(nil), // 749: forge.DeleteComputeAllocationResponse - (*InstanceTypeAllocationStats)(nil), // 750: forge.InstanceTypeAllocationStats - (*GetRackRequest)(nil), // 751: forge.GetRackRequest - (*GetRackResponse)(nil), // 752: forge.GetRackResponse - (*RackList)(nil), // 753: forge.RackList - (*RackSearchFilter)(nil), // 754: forge.RackSearchFilter - (*RackIdList)(nil), // 755: forge.RackIdList - (*RacksByIdsRequest)(nil), // 756: forge.RacksByIdsRequest - (*Rack)(nil), // 757: forge.Rack - (*RackConfig)(nil), // 758: forge.RackConfig - (*RackStatus)(nil), // 759: forge.RackStatus - (*RackStateHistoriesRequest)(nil), // 760: forge.RackStateHistoriesRequest - (*DeleteRackRequest)(nil), // 761: forge.DeleteRackRequest - (*AdminForceDeleteRackRequest)(nil), // 762: forge.AdminForceDeleteRackRequest - (*AdminForceDeleteRackResponse)(nil), // 763: forge.AdminForceDeleteRackResponse - (*RackCapabilityCompute)(nil), // 764: forge.RackCapabilityCompute - (*RackCapabilitySwitch)(nil), // 765: forge.RackCapabilitySwitch - (*RackCapabilityPowerShelf)(nil), // 766: forge.RackCapabilityPowerShelf - (*RackCapabilitiesSet)(nil), // 767: forge.RackCapabilitiesSet - (*RackProfile)(nil), // 768: forge.RackProfile - (*GetRackProfileRequest)(nil), // 769: forge.GetRackProfileRequest - (*GetRackProfileResponse)(nil), // 770: forge.GetRackProfileResponse - (*RackManagerForgeRequest)(nil), // 771: forge.RackManagerForgeRequest - (*RackManagerForgeResponse)(nil), // 772: forge.RackManagerForgeResponse - (*MachineNVLinkInfo)(nil), // 773: forge.MachineNVLinkInfo - (*UpdateMachineNvLinkInfoRequest)(nil), // 774: forge.UpdateMachineNvLinkInfoRequest - (*MachineSpxStatusObservation)(nil), // 775: forge.MachineSpxStatusObservation - (*MachineSpxAttachmentStatusObservation)(nil), // 776: forge.MachineSpxAttachmentStatusObservation - (*AstraConfig)(nil), // 777: forge.AstraConfig - (*AstraAttachment)(nil), // 778: forge.AstraAttachment - (*AstraConfigStatus)(nil), // 779: forge.AstraConfigStatus - (*AstraAttachmentStatus)(nil), // 780: forge.AstraAttachmentStatus - (*AstraStatus)(nil), // 781: forge.AstraStatus - (*NVLinkGpu)(nil), // 782: forge.NVLinkGpu - (*MachineNVLinkStatusObservation)(nil), // 783: forge.MachineNVLinkStatusObservation - (*MachineNVLinkGpuStatusObservation)(nil), // 784: forge.MachineNVLinkGpuStatusObservation - (*NmxcBrowseRequest)(nil), // 785: forge.NmxcBrowseRequest - (*NmxcBrowseResponse)(nil), // 786: forge.NmxcBrowseResponse - (*NVLinkPartition)(nil), // 787: forge.NVLinkPartition - (*NVLinkPartitionList)(nil), // 788: forge.NVLinkPartitionList - (*NVLinkPartitionSearchConfig)(nil), // 789: forge.NVLinkPartitionSearchConfig - (*NVLinkPartitionQuery)(nil), // 790: forge.NVLinkPartitionQuery - (*NVLinkPartitionSearchFilter)(nil), // 791: forge.NVLinkPartitionSearchFilter - (*NVLinkPartitionsByIdsRequest)(nil), // 792: forge.NVLinkPartitionsByIdsRequest - (*NVLinkPartitionIdList)(nil), // 793: forge.NVLinkPartitionIdList - (*NVLinkFabricSearchFilter)(nil), // 794: forge.NVLinkFabricSearchFilter - (*NVLinkLogicalPartitionConfig)(nil), // 795: forge.NVLinkLogicalPartitionConfig - (*NVLinkLogicalPartitionStatus)(nil), // 796: forge.NVLinkLogicalPartitionStatus - (*NVLinkLogicalPartition)(nil), // 797: forge.NVLinkLogicalPartition - (*NVLinkLogicalPartitionList)(nil), // 798: forge.NVLinkLogicalPartitionList - (*NVLinkLogicalPartitionCreationRequest)(nil), // 799: forge.NVLinkLogicalPartitionCreationRequest - (*NVLinkLogicalPartitionDeletionRequest)(nil), // 800: forge.NVLinkLogicalPartitionDeletionRequest - (*NVLinkLogicalPartitionDeletionResult)(nil), // 801: forge.NVLinkLogicalPartitionDeletionResult - (*NVLinkLogicalPartitionSearchFilter)(nil), // 802: forge.NVLinkLogicalPartitionSearchFilter - (*NVLinkLogicalPartitionsByIdsRequest)(nil), // 803: forge.NVLinkLogicalPartitionsByIdsRequest - (*NVLinkLogicalPartitionIdList)(nil), // 804: forge.NVLinkLogicalPartitionIdList - (*NVLinkLogicalPartitionUpdateRequest)(nil), // 805: forge.NVLinkLogicalPartitionUpdateRequest - (*NVLinkLogicalPartitionUpdateResult)(nil), // 806: forge.NVLinkLogicalPartitionUpdateResult - (*CreateBmcUserRequest)(nil), // 807: forge.CreateBmcUserRequest - (*CreateBmcUserResponse)(nil), // 808: forge.CreateBmcUserResponse - (*DeleteBmcUserRequest)(nil), // 809: forge.DeleteBmcUserRequest - (*DeleteBmcUserResponse)(nil), // 810: forge.DeleteBmcUserResponse - (*SetBmcRootPasswordRequest)(nil), // 811: forge.SetBmcRootPasswordRequest - (*SetBmcRootPasswordResponse)(nil), // 812: forge.SetBmcRootPasswordResponse - (*ProbeBmcVendorRequest)(nil), // 813: forge.ProbeBmcVendorRequest - (*ProbeBmcVendorResponse)(nil), // 814: forge.ProbeBmcVendorResponse - (*SetFirmwareUpdateTimeWindowRequest)(nil), // 815: forge.SetFirmwareUpdateTimeWindowRequest - (*SetFirmwareUpdateTimeWindowResponse)(nil), // 816: forge.SetFirmwareUpdateTimeWindowResponse - (*UpsertHostFirmwareConfigRequest)(nil), // 817: forge.UpsertHostFirmwareConfigRequest - (*DeleteHostFirmwareConfigRequest)(nil), // 818: forge.DeleteHostFirmwareConfigRequest - (*UpsertHostFirmwareComponentConfig)(nil), // 819: forge.UpsertHostFirmwareComponentConfig - (*HostFirmwareComponentConfigResponse)(nil), // 820: forge.HostFirmwareComponentConfigResponse - (*HostFirmwareVersionConfig)(nil), // 821: forge.HostFirmwareVersionConfig - (*HostFirmwareArtifact)(nil), // 822: forge.HostFirmwareArtifact - (*HostFirmwareConfigResponse)(nil), // 823: forge.HostFirmwareConfigResponse - (*ListHostFirmwareRequest)(nil), // 824: forge.ListHostFirmwareRequest - (*ListHostFirmwareResponse)(nil), // 825: forge.ListHostFirmwareResponse - (*AvailableHostFirmware)(nil), // 826: forge.AvailableHostFirmware - (*TrimTableRequest)(nil), // 827: forge.TrimTableRequest - (*TrimTableResponse)(nil), // 828: forge.TrimTableResponse - (*NvlinkNmxcEndpoint)(nil), // 829: forge.NvlinkNmxcEndpoint - (*NvlinkNmxcEndpointList)(nil), // 830: forge.NvlinkNmxcEndpointList - (*DeleteNvlinkNmxcEndpointRequest)(nil), // 831: forge.DeleteNvlinkNmxcEndpointRequest - (*CreateRemediationRequest)(nil), // 832: forge.CreateRemediationRequest - (*CreateRemediationResponse)(nil), // 833: forge.CreateRemediationResponse - (*RemediationIdList)(nil), // 834: forge.RemediationIdList - (*RemediationList)(nil), // 835: forge.RemediationList - (*Remediation)(nil), // 836: forge.Remediation - (*ApproveRemediationRequest)(nil), // 837: forge.ApproveRemediationRequest - (*RevokeRemediationRequest)(nil), // 838: forge.RevokeRemediationRequest - (*EnableRemediationRequest)(nil), // 839: forge.EnableRemediationRequest - (*DisableRemediationRequest)(nil), // 840: forge.DisableRemediationRequest - (*FindAppliedRemediationIdsRequest)(nil), // 841: forge.FindAppliedRemediationIdsRequest - (*AppliedRemediationIdList)(nil), // 842: forge.AppliedRemediationIdList - (*FindAppliedRemediationsRequest)(nil), // 843: forge.FindAppliedRemediationsRequest - (*AppliedRemediation)(nil), // 844: forge.AppliedRemediation - (*AppliedRemediationList)(nil), // 845: forge.AppliedRemediationList - (*GetNextRemediationForMachineRequest)(nil), // 846: forge.GetNextRemediationForMachineRequest - (*GetNextRemediationForMachineResponse)(nil), // 847: forge.GetNextRemediationForMachineResponse - (*RemediationAppliedRequest)(nil), // 848: forge.RemediationAppliedRequest - (*RemediationApplicationStatus)(nil), // 849: forge.RemediationApplicationStatus - (*SetPrimaryDpuRequest)(nil), // 850: forge.SetPrimaryDpuRequest - (*SetPrimaryInterfaceRequest)(nil), // 851: forge.SetPrimaryInterfaceRequest - (*UsernamePassword)(nil), // 852: forge.UsernamePassword - (*SessionToken)(nil), // 853: forge.SessionToken - (*DpuExtensionServiceCredential)(nil), // 854: forge.DpuExtensionServiceCredential - (*DpuExtensionServiceVersionInfo)(nil), // 855: forge.DpuExtensionServiceVersionInfo - (*DpuExtensionService)(nil), // 856: forge.DpuExtensionService - (*CreateDpuExtensionServiceRequest)(nil), // 857: forge.CreateDpuExtensionServiceRequest - (*UpdateDpuExtensionServiceRequest)(nil), // 858: forge.UpdateDpuExtensionServiceRequest - (*DeleteDpuExtensionServiceRequest)(nil), // 859: forge.DeleteDpuExtensionServiceRequest - (*DeleteDpuExtensionServiceResponse)(nil), // 860: forge.DeleteDpuExtensionServiceResponse - (*DpuExtensionServiceSearchFilter)(nil), // 861: forge.DpuExtensionServiceSearchFilter - (*DpuExtensionServiceIdList)(nil), // 862: forge.DpuExtensionServiceIdList - (*DpuExtensionServicesByIdsRequest)(nil), // 863: forge.DpuExtensionServicesByIdsRequest - (*DpuExtensionServiceList)(nil), // 864: forge.DpuExtensionServiceList - (*GetDpuExtensionServiceVersionsInfoRequest)(nil), // 865: forge.GetDpuExtensionServiceVersionsInfoRequest - (*DpuExtensionServiceVersionInfoList)(nil), // 866: forge.DpuExtensionServiceVersionInfoList - (*FindInstancesByDpuExtensionServiceRequest)(nil), // 867: forge.FindInstancesByDpuExtensionServiceRequest - (*FindInstancesByDpuExtensionServiceResponse)(nil), // 868: forge.FindInstancesByDpuExtensionServiceResponse - (*InstanceDpuExtensionServiceInfo)(nil), // 869: forge.InstanceDpuExtensionServiceInfo - (*DpuExtensionServiceObservabilityConfigPrometheus)(nil), // 870: forge.DpuExtensionServiceObservabilityConfigPrometheus - (*DpuExtensionServiceObservabilityConfigLogging)(nil), // 871: forge.DpuExtensionServiceObservabilityConfigLogging - (*DpuExtensionServiceObservabilityConfig)(nil), // 872: forge.DpuExtensionServiceObservabilityConfig - (*DpuExtensionServiceObservability)(nil), // 873: forge.DpuExtensionServiceObservability - (*ScoutStreamApiBoundMessage)(nil), // 874: forge.ScoutStreamApiBoundMessage - (*ScoutStreamScoutBoundMessage)(nil), // 875: forge.ScoutStreamScoutBoundMessage - (*ScoutStreamInitRequest)(nil), // 876: forge.ScoutStreamInitRequest - (*ScoutStreamShowConnectionsRequest)(nil), // 877: forge.ScoutStreamShowConnectionsRequest - (*ScoutStreamShowConnectionsResponse)(nil), // 878: forge.ScoutStreamShowConnectionsResponse - (*ScoutStreamDisconnectRequest)(nil), // 879: forge.ScoutStreamDisconnectRequest - (*ScoutStreamDisconnectResponse)(nil), // 880: forge.ScoutStreamDisconnectResponse - (*ScoutStreamAdminPingRequest)(nil), // 881: forge.ScoutStreamAdminPingRequest - (*ScoutStreamAdminPingResponse)(nil), // 882: forge.ScoutStreamAdminPingResponse - (*ScoutStreamAgentPingRequest)(nil), // 883: forge.ScoutStreamAgentPingRequest - (*ScoutStreamAgentPingResponse)(nil), // 884: forge.ScoutStreamAgentPingResponse - (*ScoutStreamConnectionInfo)(nil), // 885: forge.ScoutStreamConnectionInfo - (*ScoutStreamError)(nil), // 886: forge.ScoutStreamError - (*PrefixFilterPolicyEntry)(nil), // 887: forge.PrefixFilterPolicyEntry - (*RoutingProfile)(nil), // 888: forge.RoutingProfile - (*DomainLegacy)(nil), // 889: forge.DomainLegacy - (*DomainListLegacy)(nil), // 890: forge.DomainListLegacy - (*DomainDeletionLegacy)(nil), // 891: forge.DomainDeletionLegacy - (*DomainDeletionResultLegacy)(nil), // 892: forge.DomainDeletionResultLegacy - (*DomainSearchQueryLegacy)(nil), // 893: forge.DomainSearchQueryLegacy - (*PxeDomain)(nil), // 894: forge.PxeDomain - (*MachinePositionQuery)(nil), // 895: forge.MachinePositionQuery - (*MachinePositionInfoList)(nil), // 896: forge.MachinePositionInfoList - (*MachinePositionInfo)(nil), // 897: forge.MachinePositionInfo - (*ModifyDPFStateRequest)(nil), // 898: forge.ModifyDPFStateRequest - (*DPFStateResponse)(nil), // 899: forge.DPFStateResponse - (*GetDPFStateRequest)(nil), // 900: forge.GetDPFStateRequest - (*GetDPFHostSnapshotRequest)(nil), // 901: forge.GetDPFHostSnapshotRequest - (*DPFHostSnapshotResponse)(nil), // 902: forge.DPFHostSnapshotResponse - (*GetDPFServiceVersionsRequest)(nil), // 903: forge.GetDPFServiceVersionsRequest - (*DPFServiceVersion)(nil), // 904: forge.DPFServiceVersion - (*DPFServiceVersionsResponse)(nil), // 905: forge.DPFServiceVersionsResponse - (*ComponentResult)(nil), // 906: forge.ComponentResult - (*SwitchIdList)(nil), // 907: forge.SwitchIdList - (*PowerShelfIdList)(nil), // 908: forge.PowerShelfIdList - (*GetComponentInventoryRequest)(nil), // 909: forge.GetComponentInventoryRequest - (*ComponentInventoryEntry)(nil), // 910: forge.ComponentInventoryEntry - (*GetComponentInventoryResponse)(nil), // 911: forge.GetComponentInventoryResponse - (*ComponentPowerControlRequest)(nil), // 912: forge.ComponentPowerControlRequest - (*ComponentPowerControlResponse)(nil), // 913: forge.ComponentPowerControlResponse - (*ComponentConfigureSwitchCertificateRequest)(nil), // 914: forge.ComponentConfigureSwitchCertificateRequest - (*ComponentConfigureSwitchCertificateResponse)(nil), // 915: forge.ComponentConfigureSwitchCertificateResponse - (*FirmwareUpdateStatus)(nil), // 916: forge.FirmwareUpdateStatus - (*UpdateComputeTrayFirmwareTarget)(nil), // 917: forge.UpdateComputeTrayFirmwareTarget - (*UpdateSwitchFirmwareTarget)(nil), // 918: forge.UpdateSwitchFirmwareTarget - (*UpdatePowerShelfFirmwareTarget)(nil), // 919: forge.UpdatePowerShelfFirmwareTarget - (*UpdateFirmwareObjectTarget)(nil), // 920: forge.UpdateFirmwareObjectTarget - (*UpdateComponentFirmwareRequest)(nil), // 921: forge.UpdateComponentFirmwareRequest - (*UpdateComponentFirmwareResponse)(nil), // 922: forge.UpdateComponentFirmwareResponse - (*GetComponentFirmwareStatusRequest)(nil), // 923: forge.GetComponentFirmwareStatusRequest - (*GetComponentFirmwareStatusResponse)(nil), // 924: forge.GetComponentFirmwareStatusResponse - (*ListComponentFirmwareVersionsRequest)(nil), // 925: forge.ListComponentFirmwareVersionsRequest - (*ComputeTrayFirmwareVersions)(nil), // 926: forge.ComputeTrayFirmwareVersions - (*DeviceFirmwareVersions)(nil), // 927: forge.DeviceFirmwareVersions - (*ListComponentFirmwareVersionsResponse)(nil), // 928: forge.ListComponentFirmwareVersionsResponse - (*SpxPartitionCreationRequest)(nil), // 929: forge.SpxPartitionCreationRequest - (*SpxPartition)(nil), // 930: forge.SpxPartition - (*SpxPartitionIdList)(nil), // 931: forge.SpxPartitionIdList - (*SpxPartitionDeletionRequest)(nil), // 932: forge.SpxPartitionDeletionRequest - (*SpxPartitionDeletionResult)(nil), // 933: forge.SpxPartitionDeletionResult - (*SpxPartitionSearchFilter)(nil), // 934: forge.SpxPartitionSearchFilter - (*SpxPartitionList)(nil), // 935: forge.SpxPartitionList - (*SpxPartitionsByIdsRequest)(nil), // 936: forge.SpxPartitionsByIdsRequest - (*AdminForceDeleteSwitchRequest)(nil), // 937: forge.AdminForceDeleteSwitchRequest - (*AdminForceDeleteSwitchResponse)(nil), // 938: forge.AdminForceDeleteSwitchResponse - (*AdminForceDeletePowerShelfRequest)(nil), // 939: forge.AdminForceDeletePowerShelfRequest - (*AdminForceDeletePowerShelfResponse)(nil), // 940: forge.AdminForceDeletePowerShelfResponse - (*OperatingSystem)(nil), // 941: forge.OperatingSystem - (*CreateOperatingSystemRequest)(nil), // 942: forge.CreateOperatingSystemRequest - (*IpxeTemplateParameters)(nil), // 943: forge.IpxeTemplateParameters - (*IpxeTemplateArtifacts)(nil), // 944: forge.IpxeTemplateArtifacts - (*UpdateOperatingSystemRequest)(nil), // 945: forge.UpdateOperatingSystemRequest - (*DeleteOperatingSystemRequest)(nil), // 946: forge.DeleteOperatingSystemRequest - (*DeleteOperatingSystemResponse)(nil), // 947: forge.DeleteOperatingSystemResponse - (*OperatingSystemSearchFilter)(nil), // 948: forge.OperatingSystemSearchFilter - (*OperatingSystemIdList)(nil), // 949: forge.OperatingSystemIdList - (*OperatingSystemsByIdsRequest)(nil), // 950: forge.OperatingSystemsByIdsRequest - (*OperatingSystemList)(nil), // 951: forge.OperatingSystemList - (*GetOperatingSystemCachableIpxeTemplateArtifactsRequest)(nil), // 952: forge.GetOperatingSystemCachableIpxeTemplateArtifactsRequest - (*IpxeTemplateArtifactList)(nil), // 953: forge.IpxeTemplateArtifactList - (*IpxeTemplateArtifactUpdateRequest)(nil), // 954: forge.IpxeTemplateArtifactUpdateRequest - (*UpdateOperatingSystemIpxeTemplateArtifactRequest)(nil), // 955: forge.UpdateOperatingSystemIpxeTemplateArtifactRequest - (*HostRepresentorInterceptBridging)(nil), // 956: forge.HostRepresentorInterceptBridging - (*ReWrapSecretsRequest)(nil), // 957: forge.ReWrapSecretsRequest - (*ReWrapSecretsResponse)(nil), // 958: forge.ReWrapSecretsResponse - (*GetMachineBootInterfacesRequest)(nil), // 959: forge.GetMachineBootInterfacesRequest - (*MachineBootInterface)(nil), // 960: forge.MachineBootInterface - (*MachineInterfaceBootInterface)(nil), // 961: forge.MachineInterfaceBootInterface - (*PredictedBootInterface)(nil), // 962: forge.PredictedBootInterface - (*ExploredBootInterface)(nil), // 963: forge.ExploredBootInterface - (*RetainedBootInterface)(nil), // 964: forge.RetainedBootInterface - (*GetMachineBootInterfacesResponse)(nil), // 965: forge.GetMachineBootInterfacesResponse - (*GetContainerRegistryCredentialRequest)(nil), // 966: forge.GetContainerRegistryCredentialRequest - (*GetContainerRegistryCredentialResponse)(nil), // 967: forge.GetContainerRegistryCredentialResponse - (*SetContainerRegistryCredentialRequest)(nil), // 968: forge.SetContainerRegistryCredentialRequest - (*SitePrefix)(nil), // 969: forge.SitePrefix - (*SitePrefixConfig)(nil), // 970: forge.SitePrefixConfig - (*SitePrefixStatus)(nil), // 971: forge.SitePrefixStatus - (*SitePrefixSearchFilter)(nil), // 972: forge.SitePrefixSearchFilter - (*SitePrefixesByIdsRequest)(nil), // 973: forge.SitePrefixesByIdsRequest - (*SitePrefixIdList)(nil), // 974: forge.SitePrefixIdList - (*SitePrefixList)(nil), // 975: forge.SitePrefixList - nil, // 976: forge.RuntimeConfig.DpuNicFirmwareUpdateVersionEntry - (*DNSMessage_DNSQuestion)(nil), // 977: forge.DNSMessage.DNSQuestion - (*DNSMessage_DNSResponse)(nil), // 978: forge.DNSMessage.DNSResponse - (*DNSMessage_DNSResponse_DNSRR)(nil), // 979: forge.DNSMessage.DNSResponse.DNSRR - nil, // 980: forge.FabricManagerConfig.ConfigMapEntry - nil, // 981: forge.StateHistories.HistoriesEntry - nil, // 982: forge.MachineStateHistories.HistoriesEntry - nil, // 983: forge.HealthHistories.HistoriesEntry - nil, // 984: forge.TrafficInterceptBridging.HostRepresentorInterceptBridgingEntry - (*MachineCredentialsUpdateRequest_Credentials)(nil), // 985: forge.MachineCredentialsUpdateRequest.Credentials - (*ForgeAgentControlResponse_ForgeAgentControlExtraInfo)(nil), // 986: forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo - (*ForgeAgentControlResponse_Noop)(nil), // 987: forge.ForgeAgentControlResponse.Noop - (*ForgeAgentControlResponse_Reset)(nil), // 988: forge.ForgeAgentControlResponse.Reset - (*ForgeAgentControlResponse_Discovery)(nil), // 989: forge.ForgeAgentControlResponse.Discovery - (*ForgeAgentControlResponse_Rebuild)(nil), // 990: forge.ForgeAgentControlResponse.Rebuild - (*ForgeAgentControlResponse_Retry)(nil), // 991: forge.ForgeAgentControlResponse.Retry - (*ForgeAgentControlResponse_Measure)(nil), // 992: forge.ForgeAgentControlResponse.Measure - (*ForgeAgentControlResponse_LogError)(nil), // 993: forge.ForgeAgentControlResponse.LogError - (*ForgeAgentControlResponse_MachineValidation)(nil), // 994: forge.ForgeAgentControlResponse.MachineValidation - (*ForgeAgentControlResponse_MachineValidationFilter)(nil), // 995: forge.ForgeAgentControlResponse.MachineValidationFilter - (*ForgeAgentControlResponse_MlxAction)(nil), // 996: forge.ForgeAgentControlResponse.MlxAction - (*ForgeAgentControlResponse_MlxDeviceAction)(nil), // 997: forge.ForgeAgentControlResponse.MlxDeviceAction - (*ForgeAgentControlResponse_MlxDeviceNoop)(nil), // 998: forge.ForgeAgentControlResponse.MlxDeviceNoop - (*ForgeAgentControlResponse_MlxDeviceLock)(nil), // 999: forge.ForgeAgentControlResponse.MlxDeviceLock - (*ForgeAgentControlResponse_MlxDeviceUnlock)(nil), // 1000: forge.ForgeAgentControlResponse.MlxDeviceUnlock - (*ForgeAgentControlResponse_MlxDeviceApplyProfile)(nil), // 1001: forge.ForgeAgentControlResponse.MlxDeviceApplyProfile - (*ForgeAgentControlResponse_MlxDeviceApplyFirmware)(nil), // 1002: forge.ForgeAgentControlResponse.MlxDeviceApplyFirmware - (*ForgeAgentControlResponse_FirmwareUpgrade)(nil), // 1003: forge.ForgeAgentControlResponse.FirmwareUpgrade - (*ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair)(nil), // 1004: forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo.KeyValuePair - (*MachineCleanupInfo_CleanupStepResult)(nil), // 1005: forge.MachineCleanupInfo.CleanupStepResult - (*DpuReprovisioningListResponse_DpuReprovisioningListItem)(nil), // 1006: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem - (*HostReprovisioningListResponse_HostReprovisioningListItem)(nil), // 1007: forge.HostReprovisioningListResponse.HostReprovisioningListItem - (*MachineValidationTestUpdateRequest_Payload)(nil), // 1008: forge.MachineValidationTestUpdateRequest.Payload - nil, // 1009: forge.RedfishBrowseResponse.HeadersEntry - nil, // 1010: forge.RedfishActionResult.HeadersEntry - nil, // 1011: forge.UfmBrowseResponse.HeadersEntry - nil, // 1012: forge.DesiredFirmwareVersionEntry.ComponentVersionsEntry - nil, // 1013: forge.NmxcBrowseResponse.HeadersEntry - (*DPFStateResponse_DPFState)(nil), // 1014: forge.DPFStateResponse.DPFState - (*GetMachineBootInterfacesResponse_Reconciliation)(nil), // 1015: forge.GetMachineBootInterfacesResponse.Reconciliation - (*MachineId)(nil), // 1016: common.MachineId - (*timestamppb.Timestamp)(nil), // 1017: google.protobuf.Timestamp - (*VpcId)(nil), // 1018: common.VpcId - (*RouteTargets)(nil), // 1019: common.RouteTargets - (*RouteTarget)(nil), // 1020: common.RouteTarget - (*NVLinkLogicalPartitionId)(nil), // 1021: common.NVLinkLogicalPartitionId - (*VpcPrefixId)(nil), // 1022: common.VpcPrefixId - (*VpcPeeringId)(nil), // 1023: common.VpcPeeringId - (*IBPartitionId)(nil), // 1024: common.IBPartitionId - (*HealthReport)(nil), // 1025: health.HealthReport - (*PowerShelfId)(nil), // 1026: common.PowerShelfId - (*RackId)(nil), // 1027: common.RackId - (*UUID)(nil), // 1028: common.UUID - (*SwitchId)(nil), // 1029: common.SwitchId - (*RackProfileId)(nil), // 1030: common.RackProfileId - (*DomainId)(nil), // 1031: common.DomainId - (*NetworkSegmentId)(nil), // 1032: common.NetworkSegmentId - (*NetworkPrefixId)(nil), // 1033: common.NetworkPrefixId - (*InstanceId)(nil), // 1034: common.InstanceId - (*IpxeTemplateId)(nil), // 1035: common.IpxeTemplateId - (*OperatingSystemId)(nil), // 1036: common.OperatingSystemId - (*SpxPartitionId)(nil), // 1037: common.SpxPartitionId - (*NVLinkDomainId)(nil), // 1038: common.NVLinkDomainId - (*MachineInterfaceId)(nil), // 1039: common.MachineInterfaceId - (*DiscoveryInfo)(nil), // 1040: machine_discovery.DiscoveryInfo - (*durationpb.Duration)(nil), // 1041: google.protobuf.Duration - (*StringList)(nil), // 1042: common.StringList - (*Gpu)(nil), // 1043: machine_discovery.Gpu - (*DeviceId)(nil), // 1044: common.DeviceId - (*MachineValidationId)(nil), // 1045: common.MachineValidationId - (*Uint32List)(nil), // 1046: common.Uint32List - (*DpaInterfaceId)(nil), // 1047: common.DpaInterfaceId - (*ComputeAllocationId)(nil), // 1048: common.ComputeAllocationId - (*RackHardwareType)(nil), // 1049: common.RackHardwareType - (*NVLinkPartitionId)(nil), // 1050: common.NVLinkPartitionId - (*RemediationId)(nil), // 1051: common.RemediationId - (*MlxDeviceLockdownResponse)(nil), // 1052: mlx_device.MlxDeviceLockdownResponse - (*MlxDeviceProfileSyncResponse)(nil), // 1053: mlx_device.MlxDeviceProfileSyncResponse - (*MlxDeviceProfileCompareResponse)(nil), // 1054: mlx_device.MlxDeviceProfileCompareResponse - (*MlxDeviceInfoDeviceResponse)(nil), // 1055: mlx_device.MlxDeviceInfoDeviceResponse - (*MlxDeviceInfoReportResponse)(nil), // 1056: mlx_device.MlxDeviceInfoReportResponse - (*MlxDeviceRegistryListResponse)(nil), // 1057: mlx_device.MlxDeviceRegistryListResponse - (*MlxDeviceRegistryShowResponse)(nil), // 1058: mlx_device.MlxDeviceRegistryShowResponse - (*MlxDeviceConfigQueryResponse)(nil), // 1059: mlx_device.MlxDeviceConfigQueryResponse - (*MlxDeviceConfigSetResponse)(nil), // 1060: mlx_device.MlxDeviceConfigSetResponse - (*MlxDeviceConfigSyncResponse)(nil), // 1061: mlx_device.MlxDeviceConfigSyncResponse - (*MlxDeviceConfigCompareResponse)(nil), // 1062: mlx_device.MlxDeviceConfigCompareResponse - (*MlxDeviceLockdownLockRequest)(nil), // 1063: mlx_device.MlxDeviceLockdownLockRequest - (*MlxDeviceLockdownUnlockRequest)(nil), // 1064: mlx_device.MlxDeviceLockdownUnlockRequest - (*MlxDeviceLockdownStatusRequest)(nil), // 1065: mlx_device.MlxDeviceLockdownStatusRequest - (*MlxDeviceProfileSyncRequest)(nil), // 1066: mlx_device.MlxDeviceProfileSyncRequest - (*MlxDeviceProfileCompareRequest)(nil), // 1067: mlx_device.MlxDeviceProfileCompareRequest - (*MlxDeviceInfoDeviceRequest)(nil), // 1068: mlx_device.MlxDeviceInfoDeviceRequest - (*MlxDeviceInfoReportRequest)(nil), // 1069: mlx_device.MlxDeviceInfoReportRequest - (*MlxDeviceRegistryListRequest)(nil), // 1070: mlx_device.MlxDeviceRegistryListRequest - (*MlxDeviceRegistryShowRequest)(nil), // 1071: mlx_device.MlxDeviceRegistryShowRequest - (*MlxDeviceConfigQueryRequest)(nil), // 1072: mlx_device.MlxDeviceConfigQueryRequest - (*MlxDeviceConfigSetRequest)(nil), // 1073: mlx_device.MlxDeviceConfigSetRequest - (*MlxDeviceConfigSyncRequest)(nil), // 1074: mlx_device.MlxDeviceConfigSyncRequest - (*MlxDeviceConfigCompareRequest)(nil), // 1075: mlx_device.MlxDeviceConfigCompareRequest - (*Domain)(nil), // 1076: dns.Domain - (*MachineIdList)(nil), // 1077: common.MachineIdList - (*EndpointExplorationReport)(nil), // 1078: site_explorer.EndpointExplorationReport - (SystemPowerControl)(0), // 1079: common.SystemPowerControl - (*SitePrefixId)(nil), // 1080: common.SitePrefixId - (*SerializableMlxConfigProfile)(nil), // 1081: mlx_device.SerializableMlxConfigProfile - (*FirmwareFlasherProfile)(nil), // 1082: mlx_device.FirmwareFlasherProfile - (*ScoutFirmwareUpgradeTask)(nil), // 1083: scout_firmware_upgrade.ScoutFirmwareUpgradeTask - (*CreateDomainRequest)(nil), // 1084: dns.CreateDomainRequest - (*UpdateDomainRequest)(nil), // 1085: dns.UpdateDomainRequest - (*DomainDeletionRequest)(nil), // 1086: dns.DomainDeletionRequest - (*DomainSearchQuery)(nil), // 1087: dns.DomainSearchQuery - (*DnsResourceRecordLookupRequest)(nil), // 1088: dns.DnsResourceRecordLookupRequest - (*GetAllDomainsRequest)(nil), // 1089: dns.GetAllDomainsRequest - (*DomainMetadataRequest)(nil), // 1090: dns.DomainMetadataRequest - (*emptypb.Empty)(nil), // 1091: google.protobuf.Empty - (*ExploredEndpointSearchFilter)(nil), // 1092: site_explorer.ExploredEndpointSearchFilter - (*ExploredEndpointsByIdsRequest)(nil), // 1093: site_explorer.ExploredEndpointsByIdsRequest - (*ExploredManagedHostSearchFilter)(nil), // 1094: site_explorer.ExploredManagedHostSearchFilter - (*ExploredManagedHostsByIdsRequest)(nil), // 1095: site_explorer.ExploredManagedHostsByIdsRequest - (*ExploredMlxDeviceHostSearchFilter)(nil), // 1096: site_explorer.ExploredMlxDeviceHostSearchFilter - (*ExploredMlxDevicesByIdsRequest)(nil), // 1097: site_explorer.ExploredMlxDevicesByIdsRequest - (*CreateMeasurementBundleRequest)(nil), // 1098: measured_boot.CreateMeasurementBundleRequest - (*DeleteMeasurementBundleRequest)(nil), // 1099: measured_boot.DeleteMeasurementBundleRequest - (*RenameMeasurementBundleRequest)(nil), // 1100: measured_boot.RenameMeasurementBundleRequest - (*UpdateMeasurementBundleRequest)(nil), // 1101: measured_boot.UpdateMeasurementBundleRequest - (*ShowMeasurementBundleRequest)(nil), // 1102: measured_boot.ShowMeasurementBundleRequest - (*ShowMeasurementBundlesRequest)(nil), // 1103: measured_boot.ShowMeasurementBundlesRequest - (*ListMeasurementBundlesRequest)(nil), // 1104: measured_boot.ListMeasurementBundlesRequest - (*ListMeasurementBundleMachinesRequest)(nil), // 1105: measured_boot.ListMeasurementBundleMachinesRequest - (*FindClosestBundleMatchRequest)(nil), // 1106: measured_boot.FindClosestBundleMatchRequest - (*DeleteMeasurementJournalRequest)(nil), // 1107: measured_boot.DeleteMeasurementJournalRequest - (*ShowMeasurementJournalRequest)(nil), // 1108: measured_boot.ShowMeasurementJournalRequest - (*ShowMeasurementJournalsRequest)(nil), // 1109: measured_boot.ShowMeasurementJournalsRequest - (*ListMeasurementJournalRequest)(nil), // 1110: measured_boot.ListMeasurementJournalRequest - (*AttestCandidateMachineRequest)(nil), // 1111: measured_boot.AttestCandidateMachineRequest - (*ShowCandidateMachineRequest)(nil), // 1112: measured_boot.ShowCandidateMachineRequest - (*ShowCandidateMachinesRequest)(nil), // 1113: measured_boot.ShowCandidateMachinesRequest - (*ListCandidateMachinesRequest)(nil), // 1114: measured_boot.ListCandidateMachinesRequest - (*CreateMeasurementSystemProfileRequest)(nil), // 1115: measured_boot.CreateMeasurementSystemProfileRequest - (*DeleteMeasurementSystemProfileRequest)(nil), // 1116: measured_boot.DeleteMeasurementSystemProfileRequest - (*RenameMeasurementSystemProfileRequest)(nil), // 1117: measured_boot.RenameMeasurementSystemProfileRequest - (*ShowMeasurementSystemProfileRequest)(nil), // 1118: measured_boot.ShowMeasurementSystemProfileRequest - (*ShowMeasurementSystemProfilesRequest)(nil), // 1119: measured_boot.ShowMeasurementSystemProfilesRequest - (*ListMeasurementSystemProfilesRequest)(nil), // 1120: measured_boot.ListMeasurementSystemProfilesRequest - (*ListMeasurementSystemProfileBundlesRequest)(nil), // 1121: measured_boot.ListMeasurementSystemProfileBundlesRequest - (*ListMeasurementSystemProfileMachinesRequest)(nil), // 1122: measured_boot.ListMeasurementSystemProfileMachinesRequest - (*CreateMeasurementReportRequest)(nil), // 1123: measured_boot.CreateMeasurementReportRequest - (*DeleteMeasurementReportRequest)(nil), // 1124: measured_boot.DeleteMeasurementReportRequest - (*PromoteMeasurementReportRequest)(nil), // 1125: measured_boot.PromoteMeasurementReportRequest - (*RevokeMeasurementReportRequest)(nil), // 1126: measured_boot.RevokeMeasurementReportRequest - (*ShowMeasurementReportForIdRequest)(nil), // 1127: measured_boot.ShowMeasurementReportForIdRequest - (*ShowMeasurementReportsForMachineRequest)(nil), // 1128: measured_boot.ShowMeasurementReportsForMachineRequest - (*ShowMeasurementReportsRequest)(nil), // 1129: measured_boot.ShowMeasurementReportsRequest - (*ListMeasurementReportRequest)(nil), // 1130: measured_boot.ListMeasurementReportRequest - (*MatchMeasurementReportRequest)(nil), // 1131: measured_boot.MatchMeasurementReportRequest - (*ImportSiteMeasurementsRequest)(nil), // 1132: measured_boot.ImportSiteMeasurementsRequest - (*ExportSiteMeasurementsRequest)(nil), // 1133: measured_boot.ExportSiteMeasurementsRequest - (*AddMeasurementTrustedMachineRequest)(nil), // 1134: measured_boot.AddMeasurementTrustedMachineRequest - (*RemoveMeasurementTrustedMachineRequest)(nil), // 1135: measured_boot.RemoveMeasurementTrustedMachineRequest - (*AddMeasurementTrustedProfileRequest)(nil), // 1136: measured_boot.AddMeasurementTrustedProfileRequest - (*RemoveMeasurementTrustedProfileRequest)(nil), // 1137: measured_boot.RemoveMeasurementTrustedProfileRequest - (*ListMeasurementTrustedMachinesRequest)(nil), // 1138: measured_boot.ListMeasurementTrustedMachinesRequest - (*ListMeasurementTrustedProfilesRequest)(nil), // 1139: measured_boot.ListMeasurementTrustedProfilesRequest - (*ListAttestationSummaryRequest)(nil), // 1140: measured_boot.ListAttestationSummaryRequest - (*PublishMlxDeviceReportRequest)(nil), // 1141: mlx_device.PublishMlxDeviceReportRequest - (*PublishMlxObservationReportRequest)(nil), // 1142: mlx_device.PublishMlxObservationReportRequest - (*MlxAdminProfileSyncRequest)(nil), // 1143: mlx_device.MlxAdminProfileSyncRequest - (*MlxAdminProfileShowRequest)(nil), // 1144: mlx_device.MlxAdminProfileShowRequest - (*MlxAdminProfileCompareRequest)(nil), // 1145: mlx_device.MlxAdminProfileCompareRequest - (*MlxAdminProfileListRequest)(nil), // 1146: mlx_device.MlxAdminProfileListRequest - (*MlxAdminLockdownLockRequest)(nil), // 1147: mlx_device.MlxAdminLockdownLockRequest - (*MlxAdminLockdownUnlockRequest)(nil), // 1148: mlx_device.MlxAdminLockdownUnlockRequest - (*MlxAdminLockdownStatusRequest)(nil), // 1149: mlx_device.MlxAdminLockdownStatusRequest - (*MlxAdminDeviceInfoRequest)(nil), // 1150: mlx_device.MlxAdminDeviceInfoRequest - (*MlxAdminDeviceReportRequest)(nil), // 1151: mlx_device.MlxAdminDeviceReportRequest - (*MlxAdminRegistryListRequest)(nil), // 1152: mlx_device.MlxAdminRegistryListRequest - (*MlxAdminRegistryShowRequest)(nil), // 1153: mlx_device.MlxAdminRegistryShowRequest - (*MlxAdminConfigQueryRequest)(nil), // 1154: mlx_device.MlxAdminConfigQueryRequest - (*MlxAdminConfigSetRequest)(nil), // 1155: mlx_device.MlxAdminConfigSetRequest - (*MlxAdminConfigSyncRequest)(nil), // 1156: mlx_device.MlxAdminConfigSyncRequest - (*MlxAdminConfigCompareRequest)(nil), // 1157: mlx_device.MlxAdminConfigCompareRequest - (*DomainDeletionResult)(nil), // 1158: dns.DomainDeletionResult - (*DomainList)(nil), // 1159: dns.DomainList - (*DnsResourceRecordLookupResponse)(nil), // 1160: dns.DnsResourceRecordLookupResponse - (*GetAllDomainsResponse)(nil), // 1161: dns.GetAllDomainsResponse - (*DomainMetadataResponse)(nil), // 1162: dns.DomainMetadataResponse - (*SiteExplorationReport)(nil), // 1163: site_explorer.SiteExplorationReport - (*SiteExplorerLastRunResponse)(nil), // 1164: site_explorer.SiteExplorerLastRunResponse - (*ExploredEndpoint)(nil), // 1165: site_explorer.ExploredEndpoint - (*ExploredEndpointIdList)(nil), // 1166: site_explorer.ExploredEndpointIdList - (*ExploredEndpointList)(nil), // 1167: site_explorer.ExploredEndpointList - (*ExploredManagedHostIdList)(nil), // 1168: site_explorer.ExploredManagedHostIdList - (*ExploredManagedHostList)(nil), // 1169: site_explorer.ExploredManagedHostList - (*ExploredMlxDeviceHostIdList)(nil), // 1170: site_explorer.ExploredMlxDeviceHostIdList - (*ExploredMlxDeviceList)(nil), // 1171: site_explorer.ExploredMlxDeviceList - (*CreateMeasurementBundleResponse)(nil), // 1172: measured_boot.CreateMeasurementBundleResponse - (*DeleteMeasurementBundleResponse)(nil), // 1173: measured_boot.DeleteMeasurementBundleResponse - (*RenameMeasurementBundleResponse)(nil), // 1174: measured_boot.RenameMeasurementBundleResponse - (*UpdateMeasurementBundleResponse)(nil), // 1175: measured_boot.UpdateMeasurementBundleResponse - (*ShowMeasurementBundleResponse)(nil), // 1176: measured_boot.ShowMeasurementBundleResponse - (*ShowMeasurementBundlesResponse)(nil), // 1177: measured_boot.ShowMeasurementBundlesResponse - (*ListMeasurementBundlesResponse)(nil), // 1178: measured_boot.ListMeasurementBundlesResponse - (*ListMeasurementBundleMachinesResponse)(nil), // 1179: measured_boot.ListMeasurementBundleMachinesResponse - (*DeleteMeasurementJournalResponse)(nil), // 1180: measured_boot.DeleteMeasurementJournalResponse - (*ShowMeasurementJournalResponse)(nil), // 1181: measured_boot.ShowMeasurementJournalResponse - (*ShowMeasurementJournalsResponse)(nil), // 1182: measured_boot.ShowMeasurementJournalsResponse - (*ListMeasurementJournalResponse)(nil), // 1183: measured_boot.ListMeasurementJournalResponse - (*AttestCandidateMachineResponse)(nil), // 1184: measured_boot.AttestCandidateMachineResponse - (*ShowCandidateMachineResponse)(nil), // 1185: measured_boot.ShowCandidateMachineResponse - (*ShowCandidateMachinesResponse)(nil), // 1186: measured_boot.ShowCandidateMachinesResponse - (*ListCandidateMachinesResponse)(nil), // 1187: measured_boot.ListCandidateMachinesResponse - (*CreateMeasurementSystemProfileResponse)(nil), // 1188: measured_boot.CreateMeasurementSystemProfileResponse - (*DeleteMeasurementSystemProfileResponse)(nil), // 1189: measured_boot.DeleteMeasurementSystemProfileResponse - (*RenameMeasurementSystemProfileResponse)(nil), // 1190: measured_boot.RenameMeasurementSystemProfileResponse - (*ShowMeasurementSystemProfileResponse)(nil), // 1191: measured_boot.ShowMeasurementSystemProfileResponse - (*ShowMeasurementSystemProfilesResponse)(nil), // 1192: measured_boot.ShowMeasurementSystemProfilesResponse - (*ListMeasurementSystemProfilesResponse)(nil), // 1193: measured_boot.ListMeasurementSystemProfilesResponse - (*ListMeasurementSystemProfileBundlesResponse)(nil), // 1194: measured_boot.ListMeasurementSystemProfileBundlesResponse - (*ListMeasurementSystemProfileMachinesResponse)(nil), // 1195: measured_boot.ListMeasurementSystemProfileMachinesResponse - (*CreateMeasurementReportResponse)(nil), // 1196: measured_boot.CreateMeasurementReportResponse - (*DeleteMeasurementReportResponse)(nil), // 1197: measured_boot.DeleteMeasurementReportResponse - (*PromoteMeasurementReportResponse)(nil), // 1198: measured_boot.PromoteMeasurementReportResponse - (*RevokeMeasurementReportResponse)(nil), // 1199: measured_boot.RevokeMeasurementReportResponse - (*ShowMeasurementReportForIdResponse)(nil), // 1200: measured_boot.ShowMeasurementReportForIdResponse - (*ShowMeasurementReportsForMachineResponse)(nil), // 1201: measured_boot.ShowMeasurementReportsForMachineResponse - (*ShowMeasurementReportsResponse)(nil), // 1202: measured_boot.ShowMeasurementReportsResponse - (*ListMeasurementReportResponse)(nil), // 1203: measured_boot.ListMeasurementReportResponse - (*MatchMeasurementReportResponse)(nil), // 1204: measured_boot.MatchMeasurementReportResponse - (*ImportSiteMeasurementsResponse)(nil), // 1205: measured_boot.ImportSiteMeasurementsResponse - (*ExportSiteMeasurementsResponse)(nil), // 1206: measured_boot.ExportSiteMeasurementsResponse - (*AddMeasurementTrustedMachineResponse)(nil), // 1207: measured_boot.AddMeasurementTrustedMachineResponse - (*RemoveMeasurementTrustedMachineResponse)(nil), // 1208: measured_boot.RemoveMeasurementTrustedMachineResponse - (*AddMeasurementTrustedProfileResponse)(nil), // 1209: measured_boot.AddMeasurementTrustedProfileResponse - (*RemoveMeasurementTrustedProfileResponse)(nil), // 1210: measured_boot.RemoveMeasurementTrustedProfileResponse - (*ListMeasurementTrustedMachinesResponse)(nil), // 1211: measured_boot.ListMeasurementTrustedMachinesResponse - (*ListMeasurementTrustedProfilesResponse)(nil), // 1212: measured_boot.ListMeasurementTrustedProfilesResponse - (*ListAttestationSummaryResponse)(nil), // 1213: measured_boot.ListAttestationSummaryResponse - (*LockdownStatus)(nil), // 1214: site_explorer.LockdownStatus - (*PublishMlxDeviceReportResponse)(nil), // 1215: mlx_device.PublishMlxDeviceReportResponse - (*PublishMlxObservationReportResponse)(nil), // 1216: mlx_device.PublishMlxObservationReportResponse - (*MlxAdminProfileSyncResponse)(nil), // 1217: mlx_device.MlxAdminProfileSyncResponse - (*MlxAdminProfileShowResponse)(nil), // 1218: mlx_device.MlxAdminProfileShowResponse - (*MlxAdminProfileCompareResponse)(nil), // 1219: mlx_device.MlxAdminProfileCompareResponse - (*MlxAdminProfileListResponse)(nil), // 1220: mlx_device.MlxAdminProfileListResponse - (*MlxAdminLockdownLockResponse)(nil), // 1221: mlx_device.MlxAdminLockdownLockResponse - (*MlxAdminLockdownUnlockResponse)(nil), // 1222: mlx_device.MlxAdminLockdownUnlockResponse - (*MlxAdminLockdownStatusResponse)(nil), // 1223: mlx_device.MlxAdminLockdownStatusResponse - (*MlxAdminDeviceInfoResponse)(nil), // 1224: mlx_device.MlxAdminDeviceInfoResponse - (*MlxAdminDeviceReportResponse)(nil), // 1225: mlx_device.MlxAdminDeviceReportResponse - (*MlxAdminRegistryListResponse)(nil), // 1226: mlx_device.MlxAdminRegistryListResponse - (*MlxAdminRegistryShowResponse)(nil), // 1227: mlx_device.MlxAdminRegistryShowResponse - (*MlxAdminConfigQueryResponse)(nil), // 1228: mlx_device.MlxAdminConfigQueryResponse - (*MlxAdminConfigSetResponse)(nil), // 1229: mlx_device.MlxAdminConfigSetResponse - (*MlxAdminConfigSyncResponse)(nil), // 1230: mlx_device.MlxAdminConfigSyncResponse - (*MlxAdminConfigCompareResponse)(nil), // 1231: mlx_device.MlxAdminConfigCompareResponse + (*SetDpuUefiPasswordRequest)(nil), // 560: forge.SetDpuUefiPasswordRequest + (*SetDpuUefiPasswordResponse)(nil), // 561: forge.SetDpuUefiPasswordResponse + (*OsImageAttributes)(nil), // 562: forge.OsImageAttributes + (*OsImage)(nil), // 563: forge.OsImage + (*ListOsImageRequest)(nil), // 564: forge.ListOsImageRequest + (*ListOsImageResponse)(nil), // 565: forge.ListOsImageResponse + (*DeleteOsImageRequest)(nil), // 566: forge.DeleteOsImageRequest + (*DeleteOsImageResponse)(nil), // 567: forge.DeleteOsImageResponse + (*GetIpxeTemplateRequest)(nil), // 568: forge.GetIpxeTemplateRequest + (*ListIpxeTemplatesRequest)(nil), // 569: forge.ListIpxeTemplatesRequest + (*IpxeTemplateList)(nil), // 570: forge.IpxeTemplateList + (*ExpectedHostNic)(nil), // 571: forge.ExpectedHostNic + (*HostLifecycleProfile)(nil), // 572: forge.HostLifecycleProfile + (*ExpectedMachine)(nil), // 573: forge.ExpectedMachine + (*ExpectedMachineRequest)(nil), // 574: forge.ExpectedMachineRequest + (*ExpectedMachineList)(nil), // 575: forge.ExpectedMachineList + (*LinkedExpectedMachineList)(nil), // 576: forge.LinkedExpectedMachineList + (*LinkedExpectedMachine)(nil), // 577: forge.LinkedExpectedMachine + (*UnexpectedMachineList)(nil), // 578: forge.UnexpectedMachineList + (*UnexpectedMachine)(nil), // 579: forge.UnexpectedMachine + (*BatchExpectedMachineOperationRequest)(nil), // 580: forge.BatchExpectedMachineOperationRequest + (*ExpectedMachineOperationResult)(nil), // 581: forge.ExpectedMachineOperationResult + (*BatchExpectedMachineOperationResponse)(nil), // 582: forge.BatchExpectedMachineOperationResponse + (*MachineRebootCompletedResponse)(nil), // 583: forge.MachineRebootCompletedResponse + (*MachineRebootCompletedRequest)(nil), // 584: forge.MachineRebootCompletedRequest + (*ScoutFirmwareUpgradeStatusRequest)(nil), // 585: forge.ScoutFirmwareUpgradeStatusRequest + (*MachineValidationCompletedRequest)(nil), // 586: forge.MachineValidationCompletedRequest + (*MachineValidationCompletedResponse)(nil), // 587: forge.MachineValidationCompletedResponse + (*MachineValidationResult)(nil), // 588: forge.MachineValidationResult + (*MachineValidationResultPostRequest)(nil), // 589: forge.MachineValidationResultPostRequest + (*MachineValidationResultList)(nil), // 590: forge.MachineValidationResultList + (*MachineValidationGetRequest)(nil), // 591: forge.MachineValidationGetRequest + (*MachineValidationStatus)(nil), // 592: forge.MachineValidationStatus + (*MachineValidationRun)(nil), // 593: forge.MachineValidationRun + (*MachineSetAutoUpdateRequest)(nil), // 594: forge.MachineSetAutoUpdateRequest + (*MachineSetAutoUpdateResponse)(nil), // 595: forge.MachineSetAutoUpdateResponse + (*GetMachineValidationExternalConfigRequest)(nil), // 596: forge.GetMachineValidationExternalConfigRequest + (*MachineValidationExternalConfig)(nil), // 597: forge.MachineValidationExternalConfig + (*GetMachineValidationExternalConfigResponse)(nil), // 598: forge.GetMachineValidationExternalConfigResponse + (*GetMachineValidationExternalConfigsRequest)(nil), // 599: forge.GetMachineValidationExternalConfigsRequest + (*GetMachineValidationExternalConfigsResponse)(nil), // 600: forge.GetMachineValidationExternalConfigsResponse + (*AddUpdateMachineValidationExternalConfigRequest)(nil), // 601: forge.AddUpdateMachineValidationExternalConfigRequest + (*RemoveMachineValidationExternalConfigRequest)(nil), // 602: forge.RemoveMachineValidationExternalConfigRequest + (*MachineValidationOnDemandRequest)(nil), // 603: forge.MachineValidationOnDemandRequest + (*MachineValidationOnDemandResponse)(nil), // 604: forge.MachineValidationOnDemandResponse + (*FirmwareUpgradeActivity)(nil), // 605: forge.FirmwareUpgradeActivity + (*NvosUpdateActivity)(nil), // 606: forge.NvosUpdateActivity + (*ConfigureNmxClusterActivity)(nil), // 607: forge.ConfigureNmxClusterActivity + (*PowerSequenceActivity)(nil), // 608: forge.PowerSequenceActivity + (*MaintenanceActivityConfig)(nil), // 609: forge.MaintenanceActivityConfig + (*RackMaintenanceScope)(nil), // 610: forge.RackMaintenanceScope + (*RackMaintenanceOnDemandRequest)(nil), // 611: forge.RackMaintenanceOnDemandRequest + (*RackMaintenanceOnDemandResponse)(nil), // 612: forge.RackMaintenanceOnDemandResponse + (*AdminPowerControlRequest)(nil), // 613: forge.AdminPowerControlRequest + (*AdminPowerControlResponse)(nil), // 614: forge.AdminPowerControlResponse + (*GetRedfishJobStateRequest)(nil), // 615: forge.GetRedfishJobStateRequest + (*GetRedfishJobStateResponse)(nil), // 616: forge.GetRedfishJobStateResponse + (*MachineValidationRunList)(nil), // 617: forge.MachineValidationRunList + (*MachineValidationRunListGetRequest)(nil), // 618: forge.MachineValidationRunListGetRequest + (*MachineValidationRunItemSearchFilter)(nil), // 619: forge.MachineValidationRunItemSearchFilter + (*MachineValidationRunItemIdList)(nil), // 620: forge.MachineValidationRunItemIdList + (*MachineValidationRunItemsByIdsRequest)(nil), // 621: forge.MachineValidationRunItemsByIdsRequest + (*MachineValidationRunItemList)(nil), // 622: forge.MachineValidationRunItemList + (*MachineValidationRunItem)(nil), // 623: forge.MachineValidationRunItem + (*MachineValidationAttemptGetRequest)(nil), // 624: forge.MachineValidationAttemptGetRequest + (*MachineValidationAttempt)(nil), // 625: forge.MachineValidationAttempt + (*MachineValidationHeartbeatRequest)(nil), // 626: forge.MachineValidationHeartbeatRequest + (*MachineValidationHeartbeatResponse)(nil), // 627: forge.MachineValidationHeartbeatResponse + (*IsBmcInManagedHostResponse)(nil), // 628: forge.IsBmcInManagedHostResponse + (*BmcCredentialStatusResponse)(nil), // 629: forge.BmcCredentialStatusResponse + (*MachineValidationTestsGetRequest)(nil), // 630: forge.MachineValidationTestsGetRequest + (*MachineValidationTestUpdateRequest)(nil), // 631: forge.MachineValidationTestUpdateRequest + (*MachineValidationTestAddRequest)(nil), // 632: forge.MachineValidationTestAddRequest + (*MachineValidationTestAddUpdateResponse)(nil), // 633: forge.MachineValidationTestAddUpdateResponse + (*MachineValidationTestsGetResponse)(nil), // 634: forge.MachineValidationTestsGetResponse + (*MachineValidationTestVerfiedRequest)(nil), // 635: forge.MachineValidationTestVerfiedRequest + (*MachineValidationTestVerfiedResponse)(nil), // 636: forge.MachineValidationTestVerfiedResponse + (*MachineValidationTest)(nil), // 637: forge.MachineValidationTest + (*MachineValidationTestNextVersionResponse)(nil), // 638: forge.MachineValidationTestNextVersionResponse + (*MachineValidationTestNextVersionRequest)(nil), // 639: forge.MachineValidationTestNextVersionRequest + (*MachineValidationTestEnableDisableTestRequest)(nil), // 640: forge.MachineValidationTestEnableDisableTestRequest + (*MachineValidationTestEnableDisableTestResponse)(nil), // 641: forge.MachineValidationTestEnableDisableTestResponse + (*MachineValidationRunRequest)(nil), // 642: forge.MachineValidationRunRequest + (*MachineValidationRunResponse)(nil), // 643: forge.MachineValidationRunResponse + (*MachineCapabilityAttributesCpu)(nil), // 644: forge.MachineCapabilityAttributesCpu + (*MachineCapabilityAttributesGpu)(nil), // 645: forge.MachineCapabilityAttributesGpu + (*MachineCapabilityAttributesMemory)(nil), // 646: forge.MachineCapabilityAttributesMemory + (*MachineCapabilityAttributesStorage)(nil), // 647: forge.MachineCapabilityAttributesStorage + (*MachineCapabilityAttributesNetwork)(nil), // 648: forge.MachineCapabilityAttributesNetwork + (*MachineCapabilityAttributesInfiniband)(nil), // 649: forge.MachineCapabilityAttributesInfiniband + (*MachineCapabilityAttributesDpu)(nil), // 650: forge.MachineCapabilityAttributesDpu + (*MachineCapabilitiesSet)(nil), // 651: forge.MachineCapabilitiesSet + (*InstanceTypeAttributes)(nil), // 652: forge.InstanceTypeAttributes + (*InstanceType)(nil), // 653: forge.InstanceType + (*InstanceTypeMachineCapabilityFilterAttributes)(nil), // 654: forge.InstanceTypeMachineCapabilityFilterAttributes + (*CreateInstanceTypeRequest)(nil), // 655: forge.CreateInstanceTypeRequest + (*CreateInstanceTypeResponse)(nil), // 656: forge.CreateInstanceTypeResponse + (*FindInstanceTypeIdsRequest)(nil), // 657: forge.FindInstanceTypeIdsRequest + (*FindInstanceTypeIdsResponse)(nil), // 658: forge.FindInstanceTypeIdsResponse + (*FindInstanceTypesByIdsRequest)(nil), // 659: forge.FindInstanceTypesByIdsRequest + (*FindInstanceTypesByIdsResponse)(nil), // 660: forge.FindInstanceTypesByIdsResponse + (*DeleteInstanceTypeRequest)(nil), // 661: forge.DeleteInstanceTypeRequest + (*DeleteInstanceTypeResponse)(nil), // 662: forge.DeleteInstanceTypeResponse + (*UpdateInstanceTypeResponse)(nil), // 663: forge.UpdateInstanceTypeResponse + (*UpdateInstanceTypeRequest)(nil), // 664: forge.UpdateInstanceTypeRequest + (*AssociateMachinesWithInstanceTypeRequest)(nil), // 665: forge.AssociateMachinesWithInstanceTypeRequest + (*AssociateMachinesWithInstanceTypeResponse)(nil), // 666: forge.AssociateMachinesWithInstanceTypeResponse + (*RemoveMachineInstanceTypeAssociationRequest)(nil), // 667: forge.RemoveMachineInstanceTypeAssociationRequest + (*RemoveMachineInstanceTypeAssociationResponse)(nil), // 668: forge.RemoveMachineInstanceTypeAssociationResponse + (*RedfishBrowseRequest)(nil), // 669: forge.RedfishBrowseRequest + (*RedfishBrowseResponse)(nil), // 670: forge.RedfishBrowseResponse + (*RedfishListActionsRequest)(nil), // 671: forge.RedfishListActionsRequest + (*RedfishListActionsResponse)(nil), // 672: forge.RedfishListActionsResponse + (*RedfishAction)(nil), // 673: forge.RedfishAction + (*OptionalRedfishActionResult)(nil), // 674: forge.OptionalRedfishActionResult + (*RedfishActionResult)(nil), // 675: forge.RedfishActionResult + (*RedfishCreateActionRequest)(nil), // 676: forge.RedfishCreateActionRequest + (*RedfishCreateActionResponse)(nil), // 677: forge.RedfishCreateActionResponse + (*RedfishActionID)(nil), // 678: forge.RedfishActionID + (*RedfishApproveActionResponse)(nil), // 679: forge.RedfishApproveActionResponse + (*RedfishApplyActionResponse)(nil), // 680: forge.RedfishApplyActionResponse + (*RedfishCancelActionResponse)(nil), // 681: forge.RedfishCancelActionResponse + (*UfmBrowseRequest)(nil), // 682: forge.UfmBrowseRequest + (*UfmBrowseResponse)(nil), // 683: forge.UfmBrowseResponse + (*NetworkSecurityGroupAttributes)(nil), // 684: forge.NetworkSecurityGroupAttributes + (*NetworkSecurityGroup)(nil), // 685: forge.NetworkSecurityGroup + (*CreateNetworkSecurityGroupRequest)(nil), // 686: forge.CreateNetworkSecurityGroupRequest + (*CreateNetworkSecurityGroupResponse)(nil), // 687: forge.CreateNetworkSecurityGroupResponse + (*FindNetworkSecurityGroupIdsRequest)(nil), // 688: forge.FindNetworkSecurityGroupIdsRequest + (*FindNetworkSecurityGroupIdsResponse)(nil), // 689: forge.FindNetworkSecurityGroupIdsResponse + (*FindNetworkSecurityGroupsByIdsRequest)(nil), // 690: forge.FindNetworkSecurityGroupsByIdsRequest + (*FindNetworkSecurityGroupsByIdsResponse)(nil), // 691: forge.FindNetworkSecurityGroupsByIdsResponse + (*UpdateNetworkSecurityGroupResponse)(nil), // 692: forge.UpdateNetworkSecurityGroupResponse + (*UpdateNetworkSecurityGroupRequest)(nil), // 693: forge.UpdateNetworkSecurityGroupRequest + (*DeleteNetworkSecurityGroupRequest)(nil), // 694: forge.DeleteNetworkSecurityGroupRequest + (*DeleteNetworkSecurityGroupResponse)(nil), // 695: forge.DeleteNetworkSecurityGroupResponse + (*NetworkSecurityGroupStatus)(nil), // 696: forge.NetworkSecurityGroupStatus + (*NetworkSecurityGroupPropagationObjectStatus)(nil), // 697: forge.NetworkSecurityGroupPropagationObjectStatus + (*GetNetworkSecurityGroupPropagationStatusResponse)(nil), // 698: forge.GetNetworkSecurityGroupPropagationStatusResponse + (*NetworkSecurityGroupIdList)(nil), // 699: forge.NetworkSecurityGroupIdList + (*GetNetworkSecurityGroupPropagationStatusRequest)(nil), // 700: forge.GetNetworkSecurityGroupPropagationStatusRequest + (*NetworkSecurityGroupRuleAttributes)(nil), // 701: forge.NetworkSecurityGroupRuleAttributes + (*ResolvedNetworkSecurityGroupRule)(nil), // 702: forge.ResolvedNetworkSecurityGroupRule + (*GetNetworkSecurityGroupAttachmentsRequest)(nil), // 703: forge.GetNetworkSecurityGroupAttachmentsRequest + (*NetworkSecurityGroupAttachments)(nil), // 704: forge.NetworkSecurityGroupAttachments + (*GetNetworkSecurityGroupAttachmentsResponse)(nil), // 705: forge.GetNetworkSecurityGroupAttachmentsResponse + (*GetDesiredFirmwareVersionsRequest)(nil), // 706: forge.GetDesiredFirmwareVersionsRequest + (*GetDesiredFirmwareVersionsResponse)(nil), // 707: forge.GetDesiredFirmwareVersionsResponse + (*DesiredFirmwareVersionEntry)(nil), // 708: forge.DesiredFirmwareVersionEntry + (*SkuComponentChassis)(nil), // 709: forge.SkuComponentChassis + (*SkuComponentCpu)(nil), // 710: forge.SkuComponentCpu + (*SkuComponentGpu)(nil), // 711: forge.SkuComponentGpu + (*SkuComponentEthernetDevices)(nil), // 712: forge.SkuComponentEthernetDevices + (*SkuComponentInfinibandDevices)(nil), // 713: forge.SkuComponentInfinibandDevices + (*SkuComponentStorage)(nil), // 714: forge.SkuComponentStorage + (*SkuComponentStorageController)(nil), // 715: forge.SkuComponentStorageController + (*SkuComponentMemory)(nil), // 716: forge.SkuComponentMemory + (*SkuComponentTpm)(nil), // 717: forge.SkuComponentTpm + (*SkuComponents)(nil), // 718: forge.SkuComponents + (*Sku)(nil), // 719: forge.Sku + (*SkuMachinePair)(nil), // 720: forge.SkuMachinePair + (*RemoveSkuRequest)(nil), // 721: forge.RemoveSkuRequest + (*SkuList)(nil), // 722: forge.SkuList + (*SkuIdList)(nil), // 723: forge.SkuIdList + (*SkuStatus)(nil), // 724: forge.SkuStatus + (*SkusByIdsRequest)(nil), // 725: forge.SkusByIdsRequest + (*SkuSearchFilter)(nil), // 726: forge.SkuSearchFilter + (*DpaInterface)(nil), // 727: forge.DpaInterface + (*DpaInterfaceCreationRequest)(nil), // 728: forge.DpaInterfaceCreationRequest + (*DpaInterfaceIdList)(nil), // 729: forge.DpaInterfaceIdList + (*DpaInterfacesByIdsRequest)(nil), // 730: forge.DpaInterfacesByIdsRequest + (*DpaInterfaceList)(nil), // 731: forge.DpaInterfaceList + (*DpaNetworkObservationSetRequest)(nil), // 732: forge.DpaNetworkObservationSetRequest + (*DpaInterfaceDeletionRequest)(nil), // 733: forge.DpaInterfaceDeletionRequest + (*DpaInterfaceDeletionResult)(nil), // 734: forge.DpaInterfaceDeletionResult + (*SkuUpdateMetadataRequest)(nil), // 735: forge.SkuUpdateMetadataRequest + (*PowerOptionRequest)(nil), // 736: forge.PowerOptionRequest + (*PowerOptionUpdateRequest)(nil), // 737: forge.PowerOptionUpdateRequest + (*PowerOptions)(nil), // 738: forge.PowerOptions + (*PowerOptionResponse)(nil), // 739: forge.PowerOptionResponse + (*ComputeAllocationAttributes)(nil), // 740: forge.ComputeAllocationAttributes + (*ComputeAllocation)(nil), // 741: forge.ComputeAllocation + (*CreateComputeAllocationRequest)(nil), // 742: forge.CreateComputeAllocationRequest + (*CreateComputeAllocationResponse)(nil), // 743: forge.CreateComputeAllocationResponse + (*FindComputeAllocationIdsRequest)(nil), // 744: forge.FindComputeAllocationIdsRequest + (*FindComputeAllocationIdsResponse)(nil), // 745: forge.FindComputeAllocationIdsResponse + (*FindComputeAllocationsByIdsRequest)(nil), // 746: forge.FindComputeAllocationsByIdsRequest + (*FindComputeAllocationsByIdsResponse)(nil), // 747: forge.FindComputeAllocationsByIdsResponse + (*UpdateComputeAllocationResponse)(nil), // 748: forge.UpdateComputeAllocationResponse + (*UpdateComputeAllocationRequest)(nil), // 749: forge.UpdateComputeAllocationRequest + (*DeleteComputeAllocationRequest)(nil), // 750: forge.DeleteComputeAllocationRequest + (*DeleteComputeAllocationResponse)(nil), // 751: forge.DeleteComputeAllocationResponse + (*InstanceTypeAllocationStats)(nil), // 752: forge.InstanceTypeAllocationStats + (*GetRackRequest)(nil), // 753: forge.GetRackRequest + (*GetRackResponse)(nil), // 754: forge.GetRackResponse + (*RackList)(nil), // 755: forge.RackList + (*RackSearchFilter)(nil), // 756: forge.RackSearchFilter + (*RackIdList)(nil), // 757: forge.RackIdList + (*RacksByIdsRequest)(nil), // 758: forge.RacksByIdsRequest + (*Rack)(nil), // 759: forge.Rack + (*RackConfig)(nil), // 760: forge.RackConfig + (*RackStatus)(nil), // 761: forge.RackStatus + (*RackStateHistoriesRequest)(nil), // 762: forge.RackStateHistoriesRequest + (*DeleteRackRequest)(nil), // 763: forge.DeleteRackRequest + (*AdminForceDeleteRackRequest)(nil), // 764: forge.AdminForceDeleteRackRequest + (*AdminForceDeleteRackResponse)(nil), // 765: forge.AdminForceDeleteRackResponse + (*RackCapabilityCompute)(nil), // 766: forge.RackCapabilityCompute + (*RackCapabilitySwitch)(nil), // 767: forge.RackCapabilitySwitch + (*RackCapabilityPowerShelf)(nil), // 768: forge.RackCapabilityPowerShelf + (*RackCapabilitiesSet)(nil), // 769: forge.RackCapabilitiesSet + (*RackProfile)(nil), // 770: forge.RackProfile + (*GetRackProfileRequest)(nil), // 771: forge.GetRackProfileRequest + (*GetRackProfileResponse)(nil), // 772: forge.GetRackProfileResponse + (*RackManagerForgeRequest)(nil), // 773: forge.RackManagerForgeRequest + (*RackManagerForgeResponse)(nil), // 774: forge.RackManagerForgeResponse + (*MachineNVLinkInfo)(nil), // 775: forge.MachineNVLinkInfo + (*UpdateMachineNvLinkInfoRequest)(nil), // 776: forge.UpdateMachineNvLinkInfoRequest + (*MachineSpxStatusObservation)(nil), // 777: forge.MachineSpxStatusObservation + (*MachineSpxAttachmentStatusObservation)(nil), // 778: forge.MachineSpxAttachmentStatusObservation + (*AstraConfig)(nil), // 779: forge.AstraConfig + (*AstraAttachment)(nil), // 780: forge.AstraAttachment + (*AstraConfigStatus)(nil), // 781: forge.AstraConfigStatus + (*AstraAttachmentStatus)(nil), // 782: forge.AstraAttachmentStatus + (*AstraStatus)(nil), // 783: forge.AstraStatus + (*NVLinkGpu)(nil), // 784: forge.NVLinkGpu + (*MachineNVLinkStatusObservation)(nil), // 785: forge.MachineNVLinkStatusObservation + (*MachineNVLinkGpuStatusObservation)(nil), // 786: forge.MachineNVLinkGpuStatusObservation + (*NmxcBrowseRequest)(nil), // 787: forge.NmxcBrowseRequest + (*NmxcBrowseResponse)(nil), // 788: forge.NmxcBrowseResponse + (*NVLinkPartition)(nil), // 789: forge.NVLinkPartition + (*NVLinkPartitionList)(nil), // 790: forge.NVLinkPartitionList + (*NVLinkPartitionSearchConfig)(nil), // 791: forge.NVLinkPartitionSearchConfig + (*NVLinkPartitionQuery)(nil), // 792: forge.NVLinkPartitionQuery + (*NVLinkPartitionSearchFilter)(nil), // 793: forge.NVLinkPartitionSearchFilter + (*NVLinkPartitionsByIdsRequest)(nil), // 794: forge.NVLinkPartitionsByIdsRequest + (*NVLinkPartitionIdList)(nil), // 795: forge.NVLinkPartitionIdList + (*NVLinkFabricSearchFilter)(nil), // 796: forge.NVLinkFabricSearchFilter + (*NVLinkLogicalPartitionConfig)(nil), // 797: forge.NVLinkLogicalPartitionConfig + (*NVLinkLogicalPartitionStatus)(nil), // 798: forge.NVLinkLogicalPartitionStatus + (*NVLinkLogicalPartition)(nil), // 799: forge.NVLinkLogicalPartition + (*NVLinkLogicalPartitionList)(nil), // 800: forge.NVLinkLogicalPartitionList + (*NVLinkLogicalPartitionCreationRequest)(nil), // 801: forge.NVLinkLogicalPartitionCreationRequest + (*NVLinkLogicalPartitionDeletionRequest)(nil), // 802: forge.NVLinkLogicalPartitionDeletionRequest + (*NVLinkLogicalPartitionDeletionResult)(nil), // 803: forge.NVLinkLogicalPartitionDeletionResult + (*NVLinkLogicalPartitionSearchFilter)(nil), // 804: forge.NVLinkLogicalPartitionSearchFilter + (*NVLinkLogicalPartitionsByIdsRequest)(nil), // 805: forge.NVLinkLogicalPartitionsByIdsRequest + (*NVLinkLogicalPartitionIdList)(nil), // 806: forge.NVLinkLogicalPartitionIdList + (*NVLinkLogicalPartitionUpdateRequest)(nil), // 807: forge.NVLinkLogicalPartitionUpdateRequest + (*NVLinkLogicalPartitionUpdateResult)(nil), // 808: forge.NVLinkLogicalPartitionUpdateResult + (*CreateBmcUserRequest)(nil), // 809: forge.CreateBmcUserRequest + (*CreateBmcUserResponse)(nil), // 810: forge.CreateBmcUserResponse + (*DeleteBmcUserRequest)(nil), // 811: forge.DeleteBmcUserRequest + (*DeleteBmcUserResponse)(nil), // 812: forge.DeleteBmcUserResponse + (*SetBmcRootPasswordRequest)(nil), // 813: forge.SetBmcRootPasswordRequest + (*SetBmcRootPasswordResponse)(nil), // 814: forge.SetBmcRootPasswordResponse + (*ProbeBmcVendorRequest)(nil), // 815: forge.ProbeBmcVendorRequest + (*ProbeBmcVendorResponse)(nil), // 816: forge.ProbeBmcVendorResponse + (*SetFirmwareUpdateTimeWindowRequest)(nil), // 817: forge.SetFirmwareUpdateTimeWindowRequest + (*SetFirmwareUpdateTimeWindowResponse)(nil), // 818: forge.SetFirmwareUpdateTimeWindowResponse + (*UpsertHostFirmwareConfigRequest)(nil), // 819: forge.UpsertHostFirmwareConfigRequest + (*DeleteHostFirmwareConfigRequest)(nil), // 820: forge.DeleteHostFirmwareConfigRequest + (*UpsertHostFirmwareComponentConfig)(nil), // 821: forge.UpsertHostFirmwareComponentConfig + (*HostFirmwareComponentConfigResponse)(nil), // 822: forge.HostFirmwareComponentConfigResponse + (*HostFirmwareVersionConfig)(nil), // 823: forge.HostFirmwareVersionConfig + (*HostFirmwareArtifact)(nil), // 824: forge.HostFirmwareArtifact + (*HostFirmwareConfigResponse)(nil), // 825: forge.HostFirmwareConfigResponse + (*ListHostFirmwareRequest)(nil), // 826: forge.ListHostFirmwareRequest + (*ListHostFirmwareResponse)(nil), // 827: forge.ListHostFirmwareResponse + (*AvailableHostFirmware)(nil), // 828: forge.AvailableHostFirmware + (*TrimTableRequest)(nil), // 829: forge.TrimTableRequest + (*TrimTableResponse)(nil), // 830: forge.TrimTableResponse + (*NvlinkNmxcEndpoint)(nil), // 831: forge.NvlinkNmxcEndpoint + (*NvlinkNmxcEndpointList)(nil), // 832: forge.NvlinkNmxcEndpointList + (*DeleteNvlinkNmxcEndpointRequest)(nil), // 833: forge.DeleteNvlinkNmxcEndpointRequest + (*CreateRemediationRequest)(nil), // 834: forge.CreateRemediationRequest + (*CreateRemediationResponse)(nil), // 835: forge.CreateRemediationResponse + (*RemediationIdList)(nil), // 836: forge.RemediationIdList + (*RemediationList)(nil), // 837: forge.RemediationList + (*Remediation)(nil), // 838: forge.Remediation + (*ApproveRemediationRequest)(nil), // 839: forge.ApproveRemediationRequest + (*RevokeRemediationRequest)(nil), // 840: forge.RevokeRemediationRequest + (*EnableRemediationRequest)(nil), // 841: forge.EnableRemediationRequest + (*DisableRemediationRequest)(nil), // 842: forge.DisableRemediationRequest + (*FindAppliedRemediationIdsRequest)(nil), // 843: forge.FindAppliedRemediationIdsRequest + (*AppliedRemediationIdList)(nil), // 844: forge.AppliedRemediationIdList + (*FindAppliedRemediationsRequest)(nil), // 845: forge.FindAppliedRemediationsRequest + (*AppliedRemediation)(nil), // 846: forge.AppliedRemediation + (*AppliedRemediationList)(nil), // 847: forge.AppliedRemediationList + (*GetNextRemediationForMachineRequest)(nil), // 848: forge.GetNextRemediationForMachineRequest + (*GetNextRemediationForMachineResponse)(nil), // 849: forge.GetNextRemediationForMachineResponse + (*RemediationAppliedRequest)(nil), // 850: forge.RemediationAppliedRequest + (*RemediationApplicationStatus)(nil), // 851: forge.RemediationApplicationStatus + (*SetPrimaryDpuRequest)(nil), // 852: forge.SetPrimaryDpuRequest + (*SetPrimaryInterfaceRequest)(nil), // 853: forge.SetPrimaryInterfaceRequest + (*UsernamePassword)(nil), // 854: forge.UsernamePassword + (*SessionToken)(nil), // 855: forge.SessionToken + (*DpuExtensionServiceCredential)(nil), // 856: forge.DpuExtensionServiceCredential + (*DpuExtensionServiceVersionInfo)(nil), // 857: forge.DpuExtensionServiceVersionInfo + (*DpuExtensionService)(nil), // 858: forge.DpuExtensionService + (*CreateDpuExtensionServiceRequest)(nil), // 859: forge.CreateDpuExtensionServiceRequest + (*UpdateDpuExtensionServiceRequest)(nil), // 860: forge.UpdateDpuExtensionServiceRequest + (*DeleteDpuExtensionServiceRequest)(nil), // 861: forge.DeleteDpuExtensionServiceRequest + (*DeleteDpuExtensionServiceResponse)(nil), // 862: forge.DeleteDpuExtensionServiceResponse + (*DpuExtensionServiceSearchFilter)(nil), // 863: forge.DpuExtensionServiceSearchFilter + (*DpuExtensionServiceIdList)(nil), // 864: forge.DpuExtensionServiceIdList + (*DpuExtensionServicesByIdsRequest)(nil), // 865: forge.DpuExtensionServicesByIdsRequest + (*DpuExtensionServiceList)(nil), // 866: forge.DpuExtensionServiceList + (*GetDpuExtensionServiceVersionsInfoRequest)(nil), // 867: forge.GetDpuExtensionServiceVersionsInfoRequest + (*DpuExtensionServiceVersionInfoList)(nil), // 868: forge.DpuExtensionServiceVersionInfoList + (*FindInstancesByDpuExtensionServiceRequest)(nil), // 869: forge.FindInstancesByDpuExtensionServiceRequest + (*FindInstancesByDpuExtensionServiceResponse)(nil), // 870: forge.FindInstancesByDpuExtensionServiceResponse + (*InstanceDpuExtensionServiceInfo)(nil), // 871: forge.InstanceDpuExtensionServiceInfo + (*DpuExtensionServiceObservabilityConfigPrometheus)(nil), // 872: forge.DpuExtensionServiceObservabilityConfigPrometheus + (*DpuExtensionServiceObservabilityConfigLogging)(nil), // 873: forge.DpuExtensionServiceObservabilityConfigLogging + (*DpuExtensionServiceObservabilityConfig)(nil), // 874: forge.DpuExtensionServiceObservabilityConfig + (*DpuExtensionServiceObservability)(nil), // 875: forge.DpuExtensionServiceObservability + (*ScoutStreamApiBoundMessage)(nil), // 876: forge.ScoutStreamApiBoundMessage + (*ScoutStreamScoutBoundMessage)(nil), // 877: forge.ScoutStreamScoutBoundMessage + (*ScoutStreamInitRequest)(nil), // 878: forge.ScoutStreamInitRequest + (*ScoutStreamShowConnectionsRequest)(nil), // 879: forge.ScoutStreamShowConnectionsRequest + (*ScoutStreamShowConnectionsResponse)(nil), // 880: forge.ScoutStreamShowConnectionsResponse + (*ScoutStreamDisconnectRequest)(nil), // 881: forge.ScoutStreamDisconnectRequest + (*ScoutStreamDisconnectResponse)(nil), // 882: forge.ScoutStreamDisconnectResponse + (*ScoutStreamAdminPingRequest)(nil), // 883: forge.ScoutStreamAdminPingRequest + (*ScoutStreamAdminPingResponse)(nil), // 884: forge.ScoutStreamAdminPingResponse + (*ScoutStreamAgentPingRequest)(nil), // 885: forge.ScoutStreamAgentPingRequest + (*ScoutStreamAgentPingResponse)(nil), // 886: forge.ScoutStreamAgentPingResponse + (*ScoutStreamConnectionInfo)(nil), // 887: forge.ScoutStreamConnectionInfo + (*ScoutStreamError)(nil), // 888: forge.ScoutStreamError + (*PrefixFilterPolicyEntry)(nil), // 889: forge.PrefixFilterPolicyEntry + (*RoutingProfile)(nil), // 890: forge.RoutingProfile + (*DomainLegacy)(nil), // 891: forge.DomainLegacy + (*DomainListLegacy)(nil), // 892: forge.DomainListLegacy + (*DomainDeletionLegacy)(nil), // 893: forge.DomainDeletionLegacy + (*DomainDeletionResultLegacy)(nil), // 894: forge.DomainDeletionResultLegacy + (*DomainSearchQueryLegacy)(nil), // 895: forge.DomainSearchQueryLegacy + (*PxeDomain)(nil), // 896: forge.PxeDomain + (*MachinePositionQuery)(nil), // 897: forge.MachinePositionQuery + (*MachinePositionInfoList)(nil), // 898: forge.MachinePositionInfoList + (*MachinePositionInfo)(nil), // 899: forge.MachinePositionInfo + (*ModifyDPFStateRequest)(nil), // 900: forge.ModifyDPFStateRequest + (*DPFStateResponse)(nil), // 901: forge.DPFStateResponse + (*GetDPFStateRequest)(nil), // 902: forge.GetDPFStateRequest + (*GetDPFHostSnapshotRequest)(nil), // 903: forge.GetDPFHostSnapshotRequest + (*DPFHostSnapshotResponse)(nil), // 904: forge.DPFHostSnapshotResponse + (*GetDPFServiceVersionsRequest)(nil), // 905: forge.GetDPFServiceVersionsRequest + (*DPFServiceVersion)(nil), // 906: forge.DPFServiceVersion + (*DPFServiceVersionsResponse)(nil), // 907: forge.DPFServiceVersionsResponse + (*ComponentResult)(nil), // 908: forge.ComponentResult + (*SwitchIdList)(nil), // 909: forge.SwitchIdList + (*PowerShelfIdList)(nil), // 910: forge.PowerShelfIdList + (*GetComponentInventoryRequest)(nil), // 911: forge.GetComponentInventoryRequest + (*ComponentInventoryEntry)(nil), // 912: forge.ComponentInventoryEntry + (*GetComponentInventoryResponse)(nil), // 913: forge.GetComponentInventoryResponse + (*ComponentPowerControlRequest)(nil), // 914: forge.ComponentPowerControlRequest + (*ComponentPowerControlResponse)(nil), // 915: forge.ComponentPowerControlResponse + (*ComponentConfigureSwitchCertificateRequest)(nil), // 916: forge.ComponentConfigureSwitchCertificateRequest + (*ComponentConfigureSwitchCertificateResponse)(nil), // 917: forge.ComponentConfigureSwitchCertificateResponse + (*FirmwareUpdateStatus)(nil), // 918: forge.FirmwareUpdateStatus + (*UpdateComputeTrayFirmwareTarget)(nil), // 919: forge.UpdateComputeTrayFirmwareTarget + (*UpdateSwitchFirmwareTarget)(nil), // 920: forge.UpdateSwitchFirmwareTarget + (*UpdatePowerShelfFirmwareTarget)(nil), // 921: forge.UpdatePowerShelfFirmwareTarget + (*UpdateFirmwareObjectTarget)(nil), // 922: forge.UpdateFirmwareObjectTarget + (*UpdateComponentFirmwareRequest)(nil), // 923: forge.UpdateComponentFirmwareRequest + (*UpdateComponentFirmwareResponse)(nil), // 924: forge.UpdateComponentFirmwareResponse + (*GetComponentFirmwareStatusRequest)(nil), // 925: forge.GetComponentFirmwareStatusRequest + (*GetComponentFirmwareStatusResponse)(nil), // 926: forge.GetComponentFirmwareStatusResponse + (*ListComponentFirmwareVersionsRequest)(nil), // 927: forge.ListComponentFirmwareVersionsRequest + (*ComputeTrayFirmwareVersions)(nil), // 928: forge.ComputeTrayFirmwareVersions + (*DeviceFirmwareVersions)(nil), // 929: forge.DeviceFirmwareVersions + (*ListComponentFirmwareVersionsResponse)(nil), // 930: forge.ListComponentFirmwareVersionsResponse + (*SpxPartitionCreationRequest)(nil), // 931: forge.SpxPartitionCreationRequest + (*SpxPartition)(nil), // 932: forge.SpxPartition + (*SpxPartitionIdList)(nil), // 933: forge.SpxPartitionIdList + (*SpxPartitionDeletionRequest)(nil), // 934: forge.SpxPartitionDeletionRequest + (*SpxPartitionDeletionResult)(nil), // 935: forge.SpxPartitionDeletionResult + (*SpxPartitionSearchFilter)(nil), // 936: forge.SpxPartitionSearchFilter + (*SpxPartitionList)(nil), // 937: forge.SpxPartitionList + (*SpxPartitionsByIdsRequest)(nil), // 938: forge.SpxPartitionsByIdsRequest + (*AdminForceDeleteSwitchRequest)(nil), // 939: forge.AdminForceDeleteSwitchRequest + (*AdminForceDeleteSwitchResponse)(nil), // 940: forge.AdminForceDeleteSwitchResponse + (*AdminForceDeletePowerShelfRequest)(nil), // 941: forge.AdminForceDeletePowerShelfRequest + (*AdminForceDeletePowerShelfResponse)(nil), // 942: forge.AdminForceDeletePowerShelfResponse + (*OperatingSystem)(nil), // 943: forge.OperatingSystem + (*CreateOperatingSystemRequest)(nil), // 944: forge.CreateOperatingSystemRequest + (*IpxeTemplateParameters)(nil), // 945: forge.IpxeTemplateParameters + (*IpxeTemplateArtifacts)(nil), // 946: forge.IpxeTemplateArtifacts + (*UpdateOperatingSystemRequest)(nil), // 947: forge.UpdateOperatingSystemRequest + (*DeleteOperatingSystemRequest)(nil), // 948: forge.DeleteOperatingSystemRequest + (*DeleteOperatingSystemResponse)(nil), // 949: forge.DeleteOperatingSystemResponse + (*OperatingSystemSearchFilter)(nil), // 950: forge.OperatingSystemSearchFilter + (*OperatingSystemIdList)(nil), // 951: forge.OperatingSystemIdList + (*OperatingSystemsByIdsRequest)(nil), // 952: forge.OperatingSystemsByIdsRequest + (*OperatingSystemList)(nil), // 953: forge.OperatingSystemList + (*GetOperatingSystemCachableIpxeTemplateArtifactsRequest)(nil), // 954: forge.GetOperatingSystemCachableIpxeTemplateArtifactsRequest + (*IpxeTemplateArtifactList)(nil), // 955: forge.IpxeTemplateArtifactList + (*IpxeTemplateArtifactUpdateRequest)(nil), // 956: forge.IpxeTemplateArtifactUpdateRequest + (*UpdateOperatingSystemIpxeTemplateArtifactRequest)(nil), // 957: forge.UpdateOperatingSystemIpxeTemplateArtifactRequest + (*HostRepresentorInterceptBridging)(nil), // 958: forge.HostRepresentorInterceptBridging + (*ReWrapSecretsRequest)(nil), // 959: forge.ReWrapSecretsRequest + (*ReWrapSecretsResponse)(nil), // 960: forge.ReWrapSecretsResponse + (*GetMachineBootInterfacesRequest)(nil), // 961: forge.GetMachineBootInterfacesRequest + (*MachineBootInterface)(nil), // 962: forge.MachineBootInterface + (*MachineInterfaceBootInterface)(nil), // 963: forge.MachineInterfaceBootInterface + (*PredictedBootInterface)(nil), // 964: forge.PredictedBootInterface + (*ExploredBootInterface)(nil), // 965: forge.ExploredBootInterface + (*RetainedBootInterface)(nil), // 966: forge.RetainedBootInterface + (*GetMachineBootInterfacesResponse)(nil), // 967: forge.GetMachineBootInterfacesResponse + (*GetContainerRegistryCredentialRequest)(nil), // 968: forge.GetContainerRegistryCredentialRequest + (*GetContainerRegistryCredentialResponse)(nil), // 969: forge.GetContainerRegistryCredentialResponse + (*SetContainerRegistryCredentialRequest)(nil), // 970: forge.SetContainerRegistryCredentialRequest + (*SitePrefix)(nil), // 971: forge.SitePrefix + (*SitePrefixConfig)(nil), // 972: forge.SitePrefixConfig + (*SitePrefixStatus)(nil), // 973: forge.SitePrefixStatus + (*SitePrefixSearchFilter)(nil), // 974: forge.SitePrefixSearchFilter + (*SitePrefixesByIdsRequest)(nil), // 975: forge.SitePrefixesByIdsRequest + (*SitePrefixIdList)(nil), // 976: forge.SitePrefixIdList + (*SitePrefixList)(nil), // 977: forge.SitePrefixList + nil, // 978: forge.RuntimeConfig.DpuNicFirmwareUpdateVersionEntry + (*DNSMessage_DNSQuestion)(nil), // 979: forge.DNSMessage.DNSQuestion + (*DNSMessage_DNSResponse)(nil), // 980: forge.DNSMessage.DNSResponse + (*DNSMessage_DNSResponse_DNSRR)(nil), // 981: forge.DNSMessage.DNSResponse.DNSRR + nil, // 982: forge.FabricManagerConfig.ConfigMapEntry + nil, // 983: forge.StateHistories.HistoriesEntry + nil, // 984: forge.MachineStateHistories.HistoriesEntry + nil, // 985: forge.HealthHistories.HistoriesEntry + nil, // 986: forge.TrafficInterceptBridging.HostRepresentorInterceptBridgingEntry + (*MachineCredentialsUpdateRequest_Credentials)(nil), // 987: forge.MachineCredentialsUpdateRequest.Credentials + (*ForgeAgentControlResponse_ForgeAgentControlExtraInfo)(nil), // 988: forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo + (*ForgeAgentControlResponse_Noop)(nil), // 989: forge.ForgeAgentControlResponse.Noop + (*ForgeAgentControlResponse_Reset)(nil), // 990: forge.ForgeAgentControlResponse.Reset + (*ForgeAgentControlResponse_Discovery)(nil), // 991: forge.ForgeAgentControlResponse.Discovery + (*ForgeAgentControlResponse_Rebuild)(nil), // 992: forge.ForgeAgentControlResponse.Rebuild + (*ForgeAgentControlResponse_Retry)(nil), // 993: forge.ForgeAgentControlResponse.Retry + (*ForgeAgentControlResponse_Measure)(nil), // 994: forge.ForgeAgentControlResponse.Measure + (*ForgeAgentControlResponse_LogError)(nil), // 995: forge.ForgeAgentControlResponse.LogError + (*ForgeAgentControlResponse_MachineValidation)(nil), // 996: forge.ForgeAgentControlResponse.MachineValidation + (*ForgeAgentControlResponse_MachineValidationFilter)(nil), // 997: forge.ForgeAgentControlResponse.MachineValidationFilter + (*ForgeAgentControlResponse_MlxAction)(nil), // 998: forge.ForgeAgentControlResponse.MlxAction + (*ForgeAgentControlResponse_MlxDeviceAction)(nil), // 999: forge.ForgeAgentControlResponse.MlxDeviceAction + (*ForgeAgentControlResponse_MlxDeviceNoop)(nil), // 1000: forge.ForgeAgentControlResponse.MlxDeviceNoop + (*ForgeAgentControlResponse_MlxDeviceLock)(nil), // 1001: forge.ForgeAgentControlResponse.MlxDeviceLock + (*ForgeAgentControlResponse_MlxDeviceUnlock)(nil), // 1002: forge.ForgeAgentControlResponse.MlxDeviceUnlock + (*ForgeAgentControlResponse_MlxDeviceApplyProfile)(nil), // 1003: forge.ForgeAgentControlResponse.MlxDeviceApplyProfile + (*ForgeAgentControlResponse_MlxDeviceApplyFirmware)(nil), // 1004: forge.ForgeAgentControlResponse.MlxDeviceApplyFirmware + (*ForgeAgentControlResponse_FirmwareUpgrade)(nil), // 1005: forge.ForgeAgentControlResponse.FirmwareUpgrade + (*ForgeAgentControlResponse_ForgeAgentControlExtraInfo_KeyValuePair)(nil), // 1006: forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo.KeyValuePair + (*MachineCleanupInfo_CleanupStepResult)(nil), // 1007: forge.MachineCleanupInfo.CleanupStepResult + (*DpuReprovisioningListResponse_DpuReprovisioningListItem)(nil), // 1008: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem + (*HostReprovisioningListResponse_HostReprovisioningListItem)(nil), // 1009: forge.HostReprovisioningListResponse.HostReprovisioningListItem + (*MachineValidationTestUpdateRequest_Payload)(nil), // 1010: forge.MachineValidationTestUpdateRequest.Payload + nil, // 1011: forge.RedfishBrowseResponse.HeadersEntry + nil, // 1012: forge.RedfishActionResult.HeadersEntry + nil, // 1013: forge.UfmBrowseResponse.HeadersEntry + nil, // 1014: forge.DesiredFirmwareVersionEntry.ComponentVersionsEntry + nil, // 1015: forge.NmxcBrowseResponse.HeadersEntry + (*DPFStateResponse_DPFState)(nil), // 1016: forge.DPFStateResponse.DPFState + (*GetMachineBootInterfacesResponse_Reconciliation)(nil), // 1017: forge.GetMachineBootInterfacesResponse.Reconciliation + (*MachineId)(nil), // 1018: common.MachineId + (*timestamppb.Timestamp)(nil), // 1019: google.protobuf.Timestamp + (*VpcId)(nil), // 1020: common.VpcId + (*RouteTargets)(nil), // 1021: common.RouteTargets + (*RouteTarget)(nil), // 1022: common.RouteTarget + (*NVLinkLogicalPartitionId)(nil), // 1023: common.NVLinkLogicalPartitionId + (*VpcPrefixId)(nil), // 1024: common.VpcPrefixId + (*VpcPeeringId)(nil), // 1025: common.VpcPeeringId + (*IBPartitionId)(nil), // 1026: common.IBPartitionId + (*HealthReport)(nil), // 1027: health.HealthReport + (*PowerShelfId)(nil), // 1028: common.PowerShelfId + (*RackId)(nil), // 1029: common.RackId + (*UUID)(nil), // 1030: common.UUID + (*SwitchId)(nil), // 1031: common.SwitchId + (*RackProfileId)(nil), // 1032: common.RackProfileId + (*DomainId)(nil), // 1033: common.DomainId + (*NetworkSegmentId)(nil), // 1034: common.NetworkSegmentId + (*NetworkPrefixId)(nil), // 1035: common.NetworkPrefixId + (*InstanceId)(nil), // 1036: common.InstanceId + (*IpxeTemplateId)(nil), // 1037: common.IpxeTemplateId + (*OperatingSystemId)(nil), // 1038: common.OperatingSystemId + (*SpxPartitionId)(nil), // 1039: common.SpxPartitionId + (*NVLinkDomainId)(nil), // 1040: common.NVLinkDomainId + (*MachineInterfaceId)(nil), // 1041: common.MachineInterfaceId + (*DiscoveryInfo)(nil), // 1042: machine_discovery.DiscoveryInfo + (*durationpb.Duration)(nil), // 1043: google.protobuf.Duration + (*StringList)(nil), // 1044: common.StringList + (*Gpu)(nil), // 1045: machine_discovery.Gpu + (*DeviceId)(nil), // 1046: common.DeviceId + (*MachineValidationId)(nil), // 1047: common.MachineValidationId + (*Uint32List)(nil), // 1048: common.Uint32List + (*DpaInterfaceId)(nil), // 1049: common.DpaInterfaceId + (*ComputeAllocationId)(nil), // 1050: common.ComputeAllocationId + (*RackHardwareType)(nil), // 1051: common.RackHardwareType + (*NVLinkPartitionId)(nil), // 1052: common.NVLinkPartitionId + (*RemediationId)(nil), // 1053: common.RemediationId + (*MlxDeviceLockdownResponse)(nil), // 1054: mlx_device.MlxDeviceLockdownResponse + (*MlxDeviceProfileSyncResponse)(nil), // 1055: mlx_device.MlxDeviceProfileSyncResponse + (*MlxDeviceProfileCompareResponse)(nil), // 1056: mlx_device.MlxDeviceProfileCompareResponse + (*MlxDeviceInfoDeviceResponse)(nil), // 1057: mlx_device.MlxDeviceInfoDeviceResponse + (*MlxDeviceInfoReportResponse)(nil), // 1058: mlx_device.MlxDeviceInfoReportResponse + (*MlxDeviceRegistryListResponse)(nil), // 1059: mlx_device.MlxDeviceRegistryListResponse + (*MlxDeviceRegistryShowResponse)(nil), // 1060: mlx_device.MlxDeviceRegistryShowResponse + (*MlxDeviceConfigQueryResponse)(nil), // 1061: mlx_device.MlxDeviceConfigQueryResponse + (*MlxDeviceConfigSetResponse)(nil), // 1062: mlx_device.MlxDeviceConfigSetResponse + (*MlxDeviceConfigSyncResponse)(nil), // 1063: mlx_device.MlxDeviceConfigSyncResponse + (*MlxDeviceConfigCompareResponse)(nil), // 1064: mlx_device.MlxDeviceConfigCompareResponse + (*MlxDeviceLockdownLockRequest)(nil), // 1065: mlx_device.MlxDeviceLockdownLockRequest + (*MlxDeviceLockdownUnlockRequest)(nil), // 1066: mlx_device.MlxDeviceLockdownUnlockRequest + (*MlxDeviceLockdownStatusRequest)(nil), // 1067: mlx_device.MlxDeviceLockdownStatusRequest + (*MlxDeviceProfileSyncRequest)(nil), // 1068: mlx_device.MlxDeviceProfileSyncRequest + (*MlxDeviceProfileCompareRequest)(nil), // 1069: mlx_device.MlxDeviceProfileCompareRequest + (*MlxDeviceInfoDeviceRequest)(nil), // 1070: mlx_device.MlxDeviceInfoDeviceRequest + (*MlxDeviceInfoReportRequest)(nil), // 1071: mlx_device.MlxDeviceInfoReportRequest + (*MlxDeviceRegistryListRequest)(nil), // 1072: mlx_device.MlxDeviceRegistryListRequest + (*MlxDeviceRegistryShowRequest)(nil), // 1073: mlx_device.MlxDeviceRegistryShowRequest + (*MlxDeviceConfigQueryRequest)(nil), // 1074: mlx_device.MlxDeviceConfigQueryRequest + (*MlxDeviceConfigSetRequest)(nil), // 1075: mlx_device.MlxDeviceConfigSetRequest + (*MlxDeviceConfigSyncRequest)(nil), // 1076: mlx_device.MlxDeviceConfigSyncRequest + (*MlxDeviceConfigCompareRequest)(nil), // 1077: mlx_device.MlxDeviceConfigCompareRequest + (*Domain)(nil), // 1078: dns.Domain + (*MachineIdList)(nil), // 1079: common.MachineIdList + (*EndpointExplorationReport)(nil), // 1080: site_explorer.EndpointExplorationReport + (SystemPowerControl)(0), // 1081: common.SystemPowerControl + (*SitePrefixId)(nil), // 1082: common.SitePrefixId + (*SerializableMlxConfigProfile)(nil), // 1083: mlx_device.SerializableMlxConfigProfile + (*FirmwareFlasherProfile)(nil), // 1084: mlx_device.FirmwareFlasherProfile + (*ScoutFirmwareUpgradeTask)(nil), // 1085: scout_firmware_upgrade.ScoutFirmwareUpgradeTask + (*CreateDomainRequest)(nil), // 1086: dns.CreateDomainRequest + (*UpdateDomainRequest)(nil), // 1087: dns.UpdateDomainRequest + (*DomainDeletionRequest)(nil), // 1088: dns.DomainDeletionRequest + (*DomainSearchQuery)(nil), // 1089: dns.DomainSearchQuery + (*DnsResourceRecordLookupRequest)(nil), // 1090: dns.DnsResourceRecordLookupRequest + (*GetAllDomainsRequest)(nil), // 1091: dns.GetAllDomainsRequest + (*DomainMetadataRequest)(nil), // 1092: dns.DomainMetadataRequest + (*emptypb.Empty)(nil), // 1093: google.protobuf.Empty + (*ExploredEndpointSearchFilter)(nil), // 1094: site_explorer.ExploredEndpointSearchFilter + (*ExploredEndpointsByIdsRequest)(nil), // 1095: site_explorer.ExploredEndpointsByIdsRequest + (*ExploredManagedHostSearchFilter)(nil), // 1096: site_explorer.ExploredManagedHostSearchFilter + (*ExploredManagedHostsByIdsRequest)(nil), // 1097: site_explorer.ExploredManagedHostsByIdsRequest + (*ExploredMlxDeviceHostSearchFilter)(nil), // 1098: site_explorer.ExploredMlxDeviceHostSearchFilter + (*ExploredMlxDevicesByIdsRequest)(nil), // 1099: site_explorer.ExploredMlxDevicesByIdsRequest + (*CreateMeasurementBundleRequest)(nil), // 1100: measured_boot.CreateMeasurementBundleRequest + (*DeleteMeasurementBundleRequest)(nil), // 1101: measured_boot.DeleteMeasurementBundleRequest + (*RenameMeasurementBundleRequest)(nil), // 1102: measured_boot.RenameMeasurementBundleRequest + (*UpdateMeasurementBundleRequest)(nil), // 1103: measured_boot.UpdateMeasurementBundleRequest + (*ShowMeasurementBundleRequest)(nil), // 1104: measured_boot.ShowMeasurementBundleRequest + (*ShowMeasurementBundlesRequest)(nil), // 1105: measured_boot.ShowMeasurementBundlesRequest + (*ListMeasurementBundlesRequest)(nil), // 1106: measured_boot.ListMeasurementBundlesRequest + (*ListMeasurementBundleMachinesRequest)(nil), // 1107: measured_boot.ListMeasurementBundleMachinesRequest + (*FindClosestBundleMatchRequest)(nil), // 1108: measured_boot.FindClosestBundleMatchRequest + (*DeleteMeasurementJournalRequest)(nil), // 1109: measured_boot.DeleteMeasurementJournalRequest + (*ShowMeasurementJournalRequest)(nil), // 1110: measured_boot.ShowMeasurementJournalRequest + (*ShowMeasurementJournalsRequest)(nil), // 1111: measured_boot.ShowMeasurementJournalsRequest + (*ListMeasurementJournalRequest)(nil), // 1112: measured_boot.ListMeasurementJournalRequest + (*AttestCandidateMachineRequest)(nil), // 1113: measured_boot.AttestCandidateMachineRequest + (*ShowCandidateMachineRequest)(nil), // 1114: measured_boot.ShowCandidateMachineRequest + (*ShowCandidateMachinesRequest)(nil), // 1115: measured_boot.ShowCandidateMachinesRequest + (*ListCandidateMachinesRequest)(nil), // 1116: measured_boot.ListCandidateMachinesRequest + (*CreateMeasurementSystemProfileRequest)(nil), // 1117: measured_boot.CreateMeasurementSystemProfileRequest + (*DeleteMeasurementSystemProfileRequest)(nil), // 1118: measured_boot.DeleteMeasurementSystemProfileRequest + (*RenameMeasurementSystemProfileRequest)(nil), // 1119: measured_boot.RenameMeasurementSystemProfileRequest + (*ShowMeasurementSystemProfileRequest)(nil), // 1120: measured_boot.ShowMeasurementSystemProfileRequest + (*ShowMeasurementSystemProfilesRequest)(nil), // 1121: measured_boot.ShowMeasurementSystemProfilesRequest + (*ListMeasurementSystemProfilesRequest)(nil), // 1122: measured_boot.ListMeasurementSystemProfilesRequest + (*ListMeasurementSystemProfileBundlesRequest)(nil), // 1123: measured_boot.ListMeasurementSystemProfileBundlesRequest + (*ListMeasurementSystemProfileMachinesRequest)(nil), // 1124: measured_boot.ListMeasurementSystemProfileMachinesRequest + (*CreateMeasurementReportRequest)(nil), // 1125: measured_boot.CreateMeasurementReportRequest + (*DeleteMeasurementReportRequest)(nil), // 1126: measured_boot.DeleteMeasurementReportRequest + (*PromoteMeasurementReportRequest)(nil), // 1127: measured_boot.PromoteMeasurementReportRequest + (*RevokeMeasurementReportRequest)(nil), // 1128: measured_boot.RevokeMeasurementReportRequest + (*ShowMeasurementReportForIdRequest)(nil), // 1129: measured_boot.ShowMeasurementReportForIdRequest + (*ShowMeasurementReportsForMachineRequest)(nil), // 1130: measured_boot.ShowMeasurementReportsForMachineRequest + (*ShowMeasurementReportsRequest)(nil), // 1131: measured_boot.ShowMeasurementReportsRequest + (*ListMeasurementReportRequest)(nil), // 1132: measured_boot.ListMeasurementReportRequest + (*MatchMeasurementReportRequest)(nil), // 1133: measured_boot.MatchMeasurementReportRequest + (*ImportSiteMeasurementsRequest)(nil), // 1134: measured_boot.ImportSiteMeasurementsRequest + (*ExportSiteMeasurementsRequest)(nil), // 1135: measured_boot.ExportSiteMeasurementsRequest + (*AddMeasurementTrustedMachineRequest)(nil), // 1136: measured_boot.AddMeasurementTrustedMachineRequest + (*RemoveMeasurementTrustedMachineRequest)(nil), // 1137: measured_boot.RemoveMeasurementTrustedMachineRequest + (*AddMeasurementTrustedProfileRequest)(nil), // 1138: measured_boot.AddMeasurementTrustedProfileRequest + (*RemoveMeasurementTrustedProfileRequest)(nil), // 1139: measured_boot.RemoveMeasurementTrustedProfileRequest + (*ListMeasurementTrustedMachinesRequest)(nil), // 1140: measured_boot.ListMeasurementTrustedMachinesRequest + (*ListMeasurementTrustedProfilesRequest)(nil), // 1141: measured_boot.ListMeasurementTrustedProfilesRequest + (*ListAttestationSummaryRequest)(nil), // 1142: measured_boot.ListAttestationSummaryRequest + (*PublishMlxDeviceReportRequest)(nil), // 1143: mlx_device.PublishMlxDeviceReportRequest + (*PublishMlxObservationReportRequest)(nil), // 1144: mlx_device.PublishMlxObservationReportRequest + (*MlxAdminProfileSyncRequest)(nil), // 1145: mlx_device.MlxAdminProfileSyncRequest + (*MlxAdminProfileShowRequest)(nil), // 1146: mlx_device.MlxAdminProfileShowRequest + (*MlxAdminProfileCompareRequest)(nil), // 1147: mlx_device.MlxAdminProfileCompareRequest + (*MlxAdminProfileListRequest)(nil), // 1148: mlx_device.MlxAdminProfileListRequest + (*MlxAdminLockdownLockRequest)(nil), // 1149: mlx_device.MlxAdminLockdownLockRequest + (*MlxAdminLockdownUnlockRequest)(nil), // 1150: mlx_device.MlxAdminLockdownUnlockRequest + (*MlxAdminLockdownStatusRequest)(nil), // 1151: mlx_device.MlxAdminLockdownStatusRequest + (*MlxAdminDeviceInfoRequest)(nil), // 1152: mlx_device.MlxAdminDeviceInfoRequest + (*MlxAdminDeviceReportRequest)(nil), // 1153: mlx_device.MlxAdminDeviceReportRequest + (*MlxAdminRegistryListRequest)(nil), // 1154: mlx_device.MlxAdminRegistryListRequest + (*MlxAdminRegistryShowRequest)(nil), // 1155: mlx_device.MlxAdminRegistryShowRequest + (*MlxAdminConfigQueryRequest)(nil), // 1156: mlx_device.MlxAdminConfigQueryRequest + (*MlxAdminConfigSetRequest)(nil), // 1157: mlx_device.MlxAdminConfigSetRequest + (*MlxAdminConfigSyncRequest)(nil), // 1158: mlx_device.MlxAdminConfigSyncRequest + (*MlxAdminConfigCompareRequest)(nil), // 1159: mlx_device.MlxAdminConfigCompareRequest + (*DomainDeletionResult)(nil), // 1160: dns.DomainDeletionResult + (*DomainList)(nil), // 1161: dns.DomainList + (*DnsResourceRecordLookupResponse)(nil), // 1162: dns.DnsResourceRecordLookupResponse + (*GetAllDomainsResponse)(nil), // 1163: dns.GetAllDomainsResponse + (*DomainMetadataResponse)(nil), // 1164: dns.DomainMetadataResponse + (*SiteExplorationReport)(nil), // 1165: site_explorer.SiteExplorationReport + (*SiteExplorerLastRunResponse)(nil), // 1166: site_explorer.SiteExplorerLastRunResponse + (*ExploredEndpoint)(nil), // 1167: site_explorer.ExploredEndpoint + (*ExploredEndpointIdList)(nil), // 1168: site_explorer.ExploredEndpointIdList + (*ExploredEndpointList)(nil), // 1169: site_explorer.ExploredEndpointList + (*ExploredManagedHostIdList)(nil), // 1170: site_explorer.ExploredManagedHostIdList + (*ExploredManagedHostList)(nil), // 1171: site_explorer.ExploredManagedHostList + (*ExploredMlxDeviceHostIdList)(nil), // 1172: site_explorer.ExploredMlxDeviceHostIdList + (*ExploredMlxDeviceList)(nil), // 1173: site_explorer.ExploredMlxDeviceList + (*CreateMeasurementBundleResponse)(nil), // 1174: measured_boot.CreateMeasurementBundleResponse + (*DeleteMeasurementBundleResponse)(nil), // 1175: measured_boot.DeleteMeasurementBundleResponse + (*RenameMeasurementBundleResponse)(nil), // 1176: measured_boot.RenameMeasurementBundleResponse + (*UpdateMeasurementBundleResponse)(nil), // 1177: measured_boot.UpdateMeasurementBundleResponse + (*ShowMeasurementBundleResponse)(nil), // 1178: measured_boot.ShowMeasurementBundleResponse + (*ShowMeasurementBundlesResponse)(nil), // 1179: measured_boot.ShowMeasurementBundlesResponse + (*ListMeasurementBundlesResponse)(nil), // 1180: measured_boot.ListMeasurementBundlesResponse + (*ListMeasurementBundleMachinesResponse)(nil), // 1181: measured_boot.ListMeasurementBundleMachinesResponse + (*DeleteMeasurementJournalResponse)(nil), // 1182: measured_boot.DeleteMeasurementJournalResponse + (*ShowMeasurementJournalResponse)(nil), // 1183: measured_boot.ShowMeasurementJournalResponse + (*ShowMeasurementJournalsResponse)(nil), // 1184: measured_boot.ShowMeasurementJournalsResponse + (*ListMeasurementJournalResponse)(nil), // 1185: measured_boot.ListMeasurementJournalResponse + (*AttestCandidateMachineResponse)(nil), // 1186: measured_boot.AttestCandidateMachineResponse + (*ShowCandidateMachineResponse)(nil), // 1187: measured_boot.ShowCandidateMachineResponse + (*ShowCandidateMachinesResponse)(nil), // 1188: measured_boot.ShowCandidateMachinesResponse + (*ListCandidateMachinesResponse)(nil), // 1189: measured_boot.ListCandidateMachinesResponse + (*CreateMeasurementSystemProfileResponse)(nil), // 1190: measured_boot.CreateMeasurementSystemProfileResponse + (*DeleteMeasurementSystemProfileResponse)(nil), // 1191: measured_boot.DeleteMeasurementSystemProfileResponse + (*RenameMeasurementSystemProfileResponse)(nil), // 1192: measured_boot.RenameMeasurementSystemProfileResponse + (*ShowMeasurementSystemProfileResponse)(nil), // 1193: measured_boot.ShowMeasurementSystemProfileResponse + (*ShowMeasurementSystemProfilesResponse)(nil), // 1194: measured_boot.ShowMeasurementSystemProfilesResponse + (*ListMeasurementSystemProfilesResponse)(nil), // 1195: measured_boot.ListMeasurementSystemProfilesResponse + (*ListMeasurementSystemProfileBundlesResponse)(nil), // 1196: measured_boot.ListMeasurementSystemProfileBundlesResponse + (*ListMeasurementSystemProfileMachinesResponse)(nil), // 1197: measured_boot.ListMeasurementSystemProfileMachinesResponse + (*CreateMeasurementReportResponse)(nil), // 1198: measured_boot.CreateMeasurementReportResponse + (*DeleteMeasurementReportResponse)(nil), // 1199: measured_boot.DeleteMeasurementReportResponse + (*PromoteMeasurementReportResponse)(nil), // 1200: measured_boot.PromoteMeasurementReportResponse + (*RevokeMeasurementReportResponse)(nil), // 1201: measured_boot.RevokeMeasurementReportResponse + (*ShowMeasurementReportForIdResponse)(nil), // 1202: measured_boot.ShowMeasurementReportForIdResponse + (*ShowMeasurementReportsForMachineResponse)(nil), // 1203: measured_boot.ShowMeasurementReportsForMachineResponse + (*ShowMeasurementReportsResponse)(nil), // 1204: measured_boot.ShowMeasurementReportsResponse + (*ListMeasurementReportResponse)(nil), // 1205: measured_boot.ListMeasurementReportResponse + (*MatchMeasurementReportResponse)(nil), // 1206: measured_boot.MatchMeasurementReportResponse + (*ImportSiteMeasurementsResponse)(nil), // 1207: measured_boot.ImportSiteMeasurementsResponse + (*ExportSiteMeasurementsResponse)(nil), // 1208: measured_boot.ExportSiteMeasurementsResponse + (*AddMeasurementTrustedMachineResponse)(nil), // 1209: measured_boot.AddMeasurementTrustedMachineResponse + (*RemoveMeasurementTrustedMachineResponse)(nil), // 1210: measured_boot.RemoveMeasurementTrustedMachineResponse + (*AddMeasurementTrustedProfileResponse)(nil), // 1211: measured_boot.AddMeasurementTrustedProfileResponse + (*RemoveMeasurementTrustedProfileResponse)(nil), // 1212: measured_boot.RemoveMeasurementTrustedProfileResponse + (*ListMeasurementTrustedMachinesResponse)(nil), // 1213: measured_boot.ListMeasurementTrustedMachinesResponse + (*ListMeasurementTrustedProfilesResponse)(nil), // 1214: measured_boot.ListMeasurementTrustedProfilesResponse + (*ListAttestationSummaryResponse)(nil), // 1215: measured_boot.ListAttestationSummaryResponse + (*LockdownStatus)(nil), // 1216: site_explorer.LockdownStatus + (*PublishMlxDeviceReportResponse)(nil), // 1217: mlx_device.PublishMlxDeviceReportResponse + (*PublishMlxObservationReportResponse)(nil), // 1218: mlx_device.PublishMlxObservationReportResponse + (*MlxAdminProfileSyncResponse)(nil), // 1219: mlx_device.MlxAdminProfileSyncResponse + (*MlxAdminProfileShowResponse)(nil), // 1220: mlx_device.MlxAdminProfileShowResponse + (*MlxAdminProfileCompareResponse)(nil), // 1221: mlx_device.MlxAdminProfileCompareResponse + (*MlxAdminProfileListResponse)(nil), // 1222: mlx_device.MlxAdminProfileListResponse + (*MlxAdminLockdownLockResponse)(nil), // 1223: mlx_device.MlxAdminLockdownLockResponse + (*MlxAdminLockdownUnlockResponse)(nil), // 1224: mlx_device.MlxAdminLockdownUnlockResponse + (*MlxAdminLockdownStatusResponse)(nil), // 1225: mlx_device.MlxAdminLockdownStatusResponse + (*MlxAdminDeviceInfoResponse)(nil), // 1226: mlx_device.MlxAdminDeviceInfoResponse + (*MlxAdminDeviceReportResponse)(nil), // 1227: mlx_device.MlxAdminDeviceReportResponse + (*MlxAdminRegistryListResponse)(nil), // 1228: mlx_device.MlxAdminRegistryListResponse + (*MlxAdminRegistryShowResponse)(nil), // 1229: mlx_device.MlxAdminRegistryShowResponse + (*MlxAdminConfigQueryResponse)(nil), // 1230: mlx_device.MlxAdminConfigQueryResponse + (*MlxAdminConfigSetResponse)(nil), // 1231: mlx_device.MlxAdminConfigSetResponse + (*MlxAdminConfigSyncResponse)(nil), // 1232: mlx_device.MlxAdminConfigSyncResponse + (*MlxAdminConfigCompareResponse)(nil), // 1233: mlx_device.MlxAdminConfigCompareResponse } var file_nico_nico_proto_depIdxs = []int32{ 364, // 0: forge.LifecycleStatus.state_reason:type_name -> forge.ControllerStateReason 366, // 1: forge.LifecycleStatus.sla:type_name -> forge.StateSla - 1016, // 2: forge.SpdmMachineAttestationStatus.machine_id:type_name -> common.MachineId + 1018, // 2: forge.SpdmMachineAttestationStatus.machine_id:type_name -> common.MachineId 0, // 3: forge.SpdmMachineAttestationStatus.attestation_status:type_name -> forge.SpdmAttestationStatus - 1016, // 4: forge.SpdmMachineAttestationTriggerResponse.machine_id:type_name -> common.MachineId - 1016, // 5: forge.SpdmAttestationDetails.machine_id:type_name -> common.MachineId - 1017, // 6: forge.SpdmAttestationDetails.started_at:type_name -> google.protobuf.Timestamp - 1017, // 7: forge.SpdmAttestationDetails.cancelled_at:type_name -> google.protobuf.Timestamp - 1017, // 8: forge.SpdmAttestationDetails.completed_at:type_name -> google.protobuf.Timestamp + 1018, // 4: forge.SpdmMachineAttestationTriggerResponse.machine_id:type_name -> common.MachineId + 1018, // 5: forge.SpdmAttestationDetails.machine_id:type_name -> common.MachineId + 1019, // 6: forge.SpdmAttestationDetails.started_at:type_name -> google.protobuf.Timestamp + 1019, // 7: forge.SpdmAttestationDetails.cancelled_at:type_name -> google.protobuf.Timestamp + 1019, // 8: forge.SpdmAttestationDetails.completed_at:type_name -> google.protobuf.Timestamp 104, // 9: forge.SpdmGetAttestationMachineResponse.attestations_details:type_name -> forge.SpdmAttestationDetails - 1016, // 10: forge.SpdmMachineAttestationTriggerRequest.machine_id:type_name -> common.MachineId - 1016, // 11: forge.SpdmListAttestationMachinesRequest.machine_id:type_name -> common.MachineId + 1018, // 10: forge.SpdmMachineAttestationTriggerRequest.machine_id:type_name -> common.MachineId + 1018, // 11: forge.SpdmListAttestationMachinesRequest.machine_id:type_name -> common.MachineId 1, // 12: forge.SpdmListAttestationMachinesRequest.selector:type_name -> forge.SpdmListAttestationMachinesRequestSelector 102, // 13: forge.SpdmListAttestationMachinesResponse.statuses:type_name -> forge.SpdmMachineAttestationStatus - 1017, // 14: forge.TenantIdentitySigningKey.expire_at:type_name -> google.protobuf.Timestamp + 1019, // 14: forge.TenantIdentitySigningKey.expire_at:type_name -> google.protobuf.Timestamp 113, // 15: forge.SetTenantIdentityConfigRequest.config:type_name -> forge.TenantIdentityConfig 113, // 16: forge.TenantIdentityConfigResponse.config:type_name -> forge.TenantIdentityConfig - 1017, // 17: forge.TenantIdentityConfigResponse.created_at:type_name -> google.protobuf.Timestamp - 1017, // 18: forge.TenantIdentityConfigResponse.updated_at:type_name -> google.protobuf.Timestamp + 1019, // 17: forge.TenantIdentityConfigResponse.created_at:type_name -> google.protobuf.Timestamp + 1019, // 18: forge.TenantIdentityConfigResponse.updated_at:type_name -> google.protobuf.Timestamp 112, // 19: forge.TenantIdentityConfigResponse.signing_keys:type_name -> forge.TenantIdentitySigningKey 117, // 20: forge.TokenDelegationResponse.client_secret_basic:type_name -> forge.ClientSecretBasicResponse - 1017, // 21: forge.TokenDelegationResponse.created_at:type_name -> google.protobuf.Timestamp - 1017, // 22: forge.TokenDelegationResponse.updated_at:type_name -> google.protobuf.Timestamp + 1019, // 21: forge.TokenDelegationResponse.created_at:type_name -> google.protobuf.Timestamp + 1019, // 22: forge.TokenDelegationResponse.updated_at:type_name -> google.protobuf.Timestamp 116, // 23: forge.TokenDelegation.client_secret_basic:type_name -> forge.ClientSecretBasic 120, // 24: forge.TokenDelegationRequest.config:type_name -> forge.TokenDelegation 123, // 25: forge.ReencryptTenantIdentitySecretsResponse.failures:type_name -> forge.ReencryptTenantIdentityFailure 2, // 26: forge.JwksRequest.kind:type_name -> forge.JwksKind 3, // 27: forge.MachineIngestionStateResponse.machine_ingestion_state:type_name -> forge.MachineIngestionState 131, // 28: forge.TpmCaAddedCaStatus.id:type_name -> forge.TpmCaCertId - 1016, // 29: forge.TpmEkCertStatus.machine_id:type_name -> common.MachineId + 1018, // 29: forge.TpmEkCertStatus.machine_id:type_name -> common.MachineId 132, // 30: forge.TpmEkCertStatusCollection.tpm_ek_cert_statuses:type_name -> forge.TpmEkCertStatus 135, // 31: forge.TpmCaCertDetailCollection.tpm_ca_cert_details:type_name -> forge.TpmCaCertDetail - 1016, // 32: forge.AttestQuoteRequest.machine_id:type_name -> common.MachineId + 1018, // 32: forge.AttestQuoteRequest.machine_id:type_name -> common.MachineId 447, // 33: forge.AttestQuoteResponse.machine_certificate:type_name -> forge.MachineCertificate 4, // 34: forge.CredentialCreationRequest.credential_type:type_name -> forge.CredentialType 4, // 35: forge.CredentialDeletionRequest.credential_type:type_name -> forge.CredentialType 5, // 36: forge.RotateCredentialRequest.credential_type:type_name -> forge.RotationCredentialType 5, // 37: forge.RotateCredentialResult.credential_type:type_name -> forge.RotationCredentialType - 1017, // 38: forge.RotateCredentialResult.started_at:type_name -> google.protobuf.Timestamp + 1019, // 38: forge.RotateCredentialResult.started_at:type_name -> google.protobuf.Timestamp 5, // 39: forge.CredentialRotationStatusRequest.credential_type:type_name -> forge.RotationCredentialType - 1017, // 40: forge.DeviceCredentialRotationStatus.quarantined_until:type_name -> google.protobuf.Timestamp - 1017, // 41: forge.DeviceCredentialRotationStatus.last_attempt_at:type_name -> google.protobuf.Timestamp - 1017, // 42: forge.CredentialRotationStatusResult.started_at:type_name -> google.protobuf.Timestamp + 1019, // 40: forge.DeviceCredentialRotationStatus.quarantined_until:type_name -> google.protobuf.Timestamp + 1019, // 41: forge.DeviceCredentialRotationStatus.last_attempt_at:type_name -> google.protobuf.Timestamp + 1019, // 42: forge.CredentialRotationStatusResult.started_at:type_name -> google.protobuf.Timestamp 147, // 43: forge.CredentialRotationStatusResult.device:type_name -> forge.DeviceCredentialRotationStatus 151, // 44: forge.BuildInfo.runtime_config:type_name -> forge.RuntimeConfig - 976, // 45: forge.RuntimeConfig.dpu_nic_firmware_update_version:type_name -> forge.RuntimeConfig.DpuNicFirmwareUpdateVersionEntry - 977, // 46: forge.DNSMessage.question:type_name -> forge.DNSMessage.DNSQuestion - 978, // 47: forge.DNSMessage.response:type_name -> forge.DNSMessage.DNSResponse - 1018, // 48: forge.VpcSearchQuery.id:type_name -> common.VpcId + 978, // 45: forge.RuntimeConfig.dpu_nic_firmware_update_version:type_name -> forge.RuntimeConfig.DpuNicFirmwareUpdateVersionEntry + 979, // 46: forge.DNSMessage.question:type_name -> forge.DNSMessage.DNSQuestion + 980, // 47: forge.DNSMessage.response:type_name -> forge.DNSMessage.DNSResponse + 1020, // 48: forge.VpcSearchQuery.id:type_name -> common.VpcId 272, // 49: forge.VpcSearchFilter.label:type_name -> forge.Label - 1018, // 50: forge.VpcIdList.vpc_ids:type_name -> common.VpcId - 1018, // 51: forge.VpcsByIdsRequest.vpc_ids:type_name -> common.VpcId - 887, // 52: forge.PrefixFilterPolicyEntries.values:type_name -> forge.PrefixFilterPolicyEntry - 1019, // 53: forge.VpcRoutingProfileOverrides.route_target_imports:type_name -> common.RouteTargets - 1019, // 54: forge.VpcRoutingProfileOverrides.route_targets_on_exports:type_name -> common.RouteTargets + 1020, // 50: forge.VpcIdList.vpc_ids:type_name -> common.VpcId + 1020, // 51: forge.VpcsByIdsRequest.vpc_ids:type_name -> common.VpcId + 889, // 52: forge.PrefixFilterPolicyEntries.values:type_name -> forge.PrefixFilterPolicyEntry + 1021, // 53: forge.VpcRoutingProfileOverrides.route_target_imports:type_name -> common.RouteTargets + 1021, // 54: forge.VpcRoutingProfileOverrides.route_targets_on_exports:type_name -> common.RouteTargets 165, // 55: forge.VpcRoutingProfileOverrides.accepted_leaks_from_underlay:type_name -> forge.PrefixFilterPolicyEntries 165, // 56: forge.VpcRoutingProfileOverrides.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntries - 1020, // 57: forge.VpcEffectiveRoutingProfile.route_target_imports:type_name -> common.RouteTarget - 1020, // 58: forge.VpcEffectiveRoutingProfile.route_targets_on_exports:type_name -> common.RouteTarget - 887, // 59: forge.VpcEffectiveRoutingProfile.accepted_leaks_from_underlay:type_name -> forge.PrefixFilterPolicyEntry - 887, // 60: forge.VpcEffectiveRoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry + 1022, // 57: forge.VpcEffectiveRoutingProfile.route_target_imports:type_name -> common.RouteTarget + 1022, // 58: forge.VpcEffectiveRoutingProfile.route_targets_on_exports:type_name -> common.RouteTarget + 889, // 59: forge.VpcEffectiveRoutingProfile.accepted_leaks_from_underlay:type_name -> forge.PrefixFilterPolicyEntry + 889, // 60: forge.VpcEffectiveRoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry 6, // 61: forge.VpcConfig.network_virtualization_type:type_name -> forge.VpcVirtualizationType - 1021, // 62: forge.VpcConfig.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 62: forge.VpcConfig.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId 166, // 63: forge.VpcConfig.routing_profile_overrides:type_name -> forge.VpcRoutingProfileOverrides 167, // 64: forge.VpcStatus.effective_routing_profile:type_name -> forge.VpcEffectiveRoutingProfile - 1018, // 65: forge.Vpc.id:type_name -> common.VpcId - 1017, // 66: forge.Vpc.created:type_name -> google.protobuf.Timestamp - 1017, // 67: forge.Vpc.updated:type_name -> google.protobuf.Timestamp - 1017, // 68: forge.Vpc.deleted:type_name -> google.protobuf.Timestamp + 1020, // 65: forge.Vpc.id:type_name -> common.VpcId + 1019, // 66: forge.Vpc.created:type_name -> google.protobuf.Timestamp + 1019, // 67: forge.Vpc.updated:type_name -> google.protobuf.Timestamp + 1019, // 68: forge.Vpc.deleted:type_name -> google.protobuf.Timestamp 6, // 69: forge.Vpc.network_virtualization_type:type_name -> forge.VpcVirtualizationType 273, // 70: forge.Vpc.metadata:type_name -> forge.Metadata - 1021, // 71: forge.Vpc.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 71: forge.Vpc.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId 169, // 72: forge.Vpc.status:type_name -> forge.VpcStatus 168, // 73: forge.Vpc.config:type_name -> forge.VpcConfig 6, // 74: forge.VpcCreationRequest.network_virtualization_type:type_name -> forge.VpcVirtualizationType - 1018, // 75: forge.VpcCreationRequest.id:type_name -> common.VpcId + 1020, // 75: forge.VpcCreationRequest.id:type_name -> common.VpcId 273, // 76: forge.VpcCreationRequest.metadata:type_name -> forge.Metadata - 1021, // 77: forge.VpcCreationRequest.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 77: forge.VpcCreationRequest.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId 166, // 78: forge.VpcCreationRequest.routing_profile_overrides:type_name -> forge.VpcRoutingProfileOverrides - 1018, // 79: forge.VpcUpdateRequest.id:type_name -> common.VpcId + 1020, // 79: forge.VpcUpdateRequest.id:type_name -> common.VpcId 273, // 80: forge.VpcUpdateRequest.metadata:type_name -> forge.Metadata - 1021, // 81: forge.VpcUpdateRequest.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 81: forge.VpcUpdateRequest.default_nvlink_logical_partition_id:type_name -> common.NVLinkLogicalPartitionId 170, // 82: forge.VpcUpdateResult.vpc:type_name -> forge.Vpc - 1018, // 83: forge.VpcUpdateVirtualizationRequest.id:type_name -> common.VpcId + 1020, // 83: forge.VpcUpdateVirtualizationRequest.id:type_name -> common.VpcId 6, // 84: forge.VpcUpdateVirtualizationRequest.network_virtualization_type:type_name -> forge.VpcVirtualizationType - 1018, // 85: forge.VpcDeletionRequest.id:type_name -> common.VpcId + 1020, // 85: forge.VpcDeletionRequest.id:type_name -> common.VpcId 170, // 86: forge.VpcList.vpcs:type_name -> forge.Vpc - 1022, // 87: forge.VpcPrefix.id:type_name -> common.VpcPrefixId - 1018, // 88: forge.VpcPrefix.vpc_id:type_name -> common.VpcId + 1024, // 87: forge.VpcPrefix.id:type_name -> common.VpcPrefixId + 1020, // 88: forge.VpcPrefix.vpc_id:type_name -> common.VpcId 180, // 89: forge.VpcPrefix.config:type_name -> forge.VpcPrefixConfig 181, // 90: forge.VpcPrefix.status:type_name -> forge.VpcPrefixStatus 273, // 91: forge.VpcPrefix.metadata:type_name -> forge.Metadata 101, // 92: forge.VpcPrefixStatus.lifecycle:type_name -> forge.LifecycleStatus 8, // 93: forge.VpcPrefixStatus.tenant_state:type_name -> forge.TenantState - 1022, // 94: forge.VpcPrefixCreationRequest.id:type_name -> common.VpcPrefixId - 1018, // 95: forge.VpcPrefixCreationRequest.vpc_id:type_name -> common.VpcId + 1024, // 94: forge.VpcPrefixCreationRequest.id:type_name -> common.VpcPrefixId + 1020, // 95: forge.VpcPrefixCreationRequest.vpc_id:type_name -> common.VpcId 180, // 96: forge.VpcPrefixCreationRequest.config:type_name -> forge.VpcPrefixConfig 273, // 97: forge.VpcPrefixCreationRequest.metadata:type_name -> forge.Metadata - 1018, // 98: forge.VpcPrefixSearchQuery.vpc_id:type_name -> common.VpcId - 1022, // 99: forge.VpcPrefixSearchQuery.tenant_prefix_id:type_name -> common.VpcPrefixId + 1020, // 98: forge.VpcPrefixSearchQuery.vpc_id:type_name -> common.VpcId + 1024, // 99: forge.VpcPrefixSearchQuery.tenant_prefix_id:type_name -> common.VpcPrefixId 7, // 100: forge.VpcPrefixSearchQuery.prefix_match_type:type_name -> forge.PrefixMatchType 10, // 101: forge.VpcPrefixSearchQuery.deleted:type_name -> forge.DeletedFilter - 1022, // 102: forge.VpcPrefixGetRequest.vpc_prefix_ids:type_name -> common.VpcPrefixId + 1024, // 102: forge.VpcPrefixGetRequest.vpc_prefix_ids:type_name -> common.VpcPrefixId 10, // 103: forge.VpcPrefixGetRequest.deleted:type_name -> forge.DeletedFilter - 1022, // 104: forge.VpcPrefixIdList.vpc_prefix_ids:type_name -> common.VpcPrefixId + 1024, // 104: forge.VpcPrefixIdList.vpc_prefix_ids:type_name -> common.VpcPrefixId 179, // 105: forge.VpcPrefixList.vpc_prefixes:type_name -> forge.VpcPrefix - 1022, // 106: forge.VpcPrefixUpdateRequest.id:type_name -> common.VpcPrefixId + 1024, // 106: forge.VpcPrefixUpdateRequest.id:type_name -> common.VpcPrefixId 180, // 107: forge.VpcPrefixUpdateRequest.config:type_name -> forge.VpcPrefixConfig 273, // 108: forge.VpcPrefixUpdateRequest.metadata:type_name -> forge.Metadata - 1022, // 109: forge.VpcPrefixDeletionRequest.id:type_name -> common.VpcPrefixId - 1022, // 110: forge.VpcPrefixStateHistoriesRequest.vpc_prefix_ids:type_name -> common.VpcPrefixId - 1023, // 111: forge.VpcPeering.id:type_name -> common.VpcPeeringId - 1018, // 112: forge.VpcPeering.vpc_id:type_name -> common.VpcId - 1018, // 113: forge.VpcPeering.peer_vpc_id:type_name -> common.VpcId - 1023, // 114: forge.VpcPeeringIdList.vpc_peering_ids:type_name -> common.VpcPeeringId + 1024, // 109: forge.VpcPrefixDeletionRequest.id:type_name -> common.VpcPrefixId + 1024, // 110: forge.VpcPrefixStateHistoriesRequest.vpc_prefix_ids:type_name -> common.VpcPrefixId + 1025, // 111: forge.VpcPeering.id:type_name -> common.VpcPeeringId + 1020, // 112: forge.VpcPeering.vpc_id:type_name -> common.VpcId + 1020, // 113: forge.VpcPeering.peer_vpc_id:type_name -> common.VpcId + 1025, // 114: forge.VpcPeeringIdList.vpc_peering_ids:type_name -> common.VpcPeeringId 191, // 115: forge.VpcPeeringList.vpc_peerings:type_name -> forge.VpcPeering - 1018, // 116: forge.VpcPeeringCreationRequest.vpc_id:type_name -> common.VpcId - 1018, // 117: forge.VpcPeeringCreationRequest.peer_vpc_id:type_name -> common.VpcId - 1023, // 118: forge.VpcPeeringCreationRequest.id:type_name -> common.VpcPeeringId - 1018, // 119: forge.VpcPeeringSearchFilter.vpc_id:type_name -> common.VpcId - 1023, // 120: forge.VpcPeeringsByIdsRequest.vpc_peering_ids:type_name -> common.VpcPeeringId - 1023, // 121: forge.VpcPeeringDeletionRequest.id:type_name -> common.VpcPeeringId + 1020, // 116: forge.VpcPeeringCreationRequest.vpc_id:type_name -> common.VpcId + 1020, // 117: forge.VpcPeeringCreationRequest.peer_vpc_id:type_name -> common.VpcId + 1025, // 118: forge.VpcPeeringCreationRequest.id:type_name -> common.VpcPeeringId + 1020, // 119: forge.VpcPeeringSearchFilter.vpc_id:type_name -> common.VpcId + 1025, // 120: forge.VpcPeeringsByIdsRequest.vpc_peering_ids:type_name -> common.VpcPeeringId + 1025, // 121: forge.VpcPeeringDeletionRequest.id:type_name -> common.VpcPeeringId 8, // 122: forge.IBPartitionStatus.state:type_name -> forge.TenantState 364, // 123: forge.IBPartitionStatus.state_reason:type_name -> forge.ControllerStateReason 366, // 124: forge.IBPartitionStatus.state_sla:type_name -> forge.StateSla - 1024, // 125: forge.IBPartition.id:type_name -> common.IBPartitionId + 1026, // 125: forge.IBPartition.id:type_name -> common.IBPartitionId 199, // 126: forge.IBPartition.config:type_name -> forge.IBPartitionConfig 200, // 127: forge.IBPartition.status:type_name -> forge.IBPartitionStatus 273, // 128: forge.IBPartition.metadata:type_name -> forge.Metadata 201, // 129: forge.IBPartitionList.ib_partitions:type_name -> forge.IBPartition 199, // 130: forge.IBPartitionCreationRequest.config:type_name -> forge.IBPartitionConfig - 1024, // 131: forge.IBPartitionCreationRequest.id:type_name -> common.IBPartitionId + 1026, // 131: forge.IBPartitionCreationRequest.id:type_name -> common.IBPartitionId 273, // 132: forge.IBPartitionCreationRequest.metadata:type_name -> forge.Metadata - 1024, // 133: forge.IBPartitionUpdateRequest.id:type_name -> common.IBPartitionId + 1026, // 133: forge.IBPartitionUpdateRequest.id:type_name -> common.IBPartitionId 199, // 134: forge.IBPartitionUpdateRequest.config:type_name -> forge.IBPartitionConfig 273, // 135: forge.IBPartitionUpdateRequest.metadata:type_name -> forge.Metadata - 1024, // 136: forge.IBPartitionDeletionRequest.id:type_name -> common.IBPartitionId - 1024, // 137: forge.IBPartitionsByIdsRequest.ib_partition_ids:type_name -> common.IBPartitionId - 1024, // 138: forge.IBPartitionIdList.ib_partition_ids:type_name -> common.IBPartitionId + 1026, // 136: forge.IBPartitionDeletionRequest.id:type_name -> common.IBPartitionId + 1026, // 137: forge.IBPartitionsByIdsRequest.ib_partition_ids:type_name -> common.IBPartitionId + 1026, // 138: forge.IBPartitionIdList.ib_partition_ids:type_name -> common.IBPartitionId 364, // 139: forge.PowerShelfStatus.state_reason:type_name -> forge.ControllerStateReason 366, // 140: forge.PowerShelfStatus.state_sla:type_name -> forge.StateSla - 1025, // 141: forge.PowerShelfStatus.health:type_name -> health.HealthReport + 1027, // 141: forge.PowerShelfStatus.health:type_name -> health.HealthReport 363, // 142: forge.PowerShelfStatus.health_sources:type_name -> forge.HealthSourceOrigin 101, // 143: forge.PowerShelfStatus.lifecycle:type_name -> forge.LifecycleStatus - 1026, // 144: forge.PowerShelf.id:type_name -> common.PowerShelfId + 1028, // 144: forge.PowerShelf.id:type_name -> common.PowerShelfId 210, // 145: forge.PowerShelf.config:type_name -> forge.PowerShelfConfig 211, // 146: forge.PowerShelf.status:type_name -> forge.PowerShelfStatus - 1017, // 147: forge.PowerShelf.deleted:type_name -> google.protobuf.Timestamp + 1019, // 147: forge.PowerShelf.deleted:type_name -> google.protobuf.Timestamp 273, // 148: forge.PowerShelf.metadata:type_name -> forge.Metadata 349, // 149: forge.PowerShelf.bmc_info:type_name -> forge.BmcInfo - 1027, // 150: forge.PowerShelf.rack_id:type_name -> common.RackId + 1029, // 150: forge.PowerShelf.rack_id:type_name -> common.RackId 212, // 151: forge.PowerShelfList.power_shelves:type_name -> forge.PowerShelf 210, // 152: forge.PowerShelfCreationRequest.config:type_name -> forge.PowerShelfConfig - 1026, // 153: forge.PowerShelfCreationRequest.id:type_name -> common.PowerShelfId - 1026, // 154: forge.PowerShelfDeletionRequest.id:type_name -> common.PowerShelfId - 1026, // 155: forge.PowerShelfMaintenanceRequest.power_shelf_ids:type_name -> common.PowerShelfId + 1028, // 153: forge.PowerShelfCreationRequest.id:type_name -> common.PowerShelfId + 1028, // 154: forge.PowerShelfDeletionRequest.id:type_name -> common.PowerShelfId + 1028, // 155: forge.PowerShelfMaintenanceRequest.power_shelf_ids:type_name -> common.PowerShelfId 9, // 156: forge.PowerShelfMaintenanceRequest.operation:type_name -> forge.PowerShelfMaintenanceOperation - 1026, // 157: forge.PowerShelfStateHistoriesRequest.power_shelf_ids:type_name -> common.PowerShelfId - 1026, // 158: forge.PowerShelfQuery.power_shelf_id:type_name -> common.PowerShelfId - 1027, // 159: forge.PowerShelfSearchFilter.rack_id:type_name -> common.RackId + 1028, // 157: forge.PowerShelfStateHistoriesRequest.power_shelf_ids:type_name -> common.PowerShelfId + 1028, // 158: forge.PowerShelfQuery.power_shelf_id:type_name -> common.PowerShelfId + 1029, // 159: forge.PowerShelfSearchFilter.rack_id:type_name -> common.RackId 10, // 160: forge.PowerShelfSearchFilter.deleted:type_name -> forge.DeletedFilter - 1026, // 161: forge.PowerShelvesByIdsRequest.power_shelf_ids:type_name -> common.PowerShelfId + 1028, // 161: forge.PowerShelvesByIdsRequest.power_shelf_ids:type_name -> common.PowerShelfId 273, // 162: forge.ExpectedPowerShelf.metadata:type_name -> forge.Metadata - 1027, // 163: forge.ExpectedPowerShelf.rack_id:type_name -> common.RackId - 1028, // 164: forge.ExpectedPowerShelf.expected_power_shelf_id:type_name -> common.UUID - 1028, // 165: forge.ExpectedPowerShelfRequest.expected_power_shelf_id:type_name -> common.UUID + 1029, // 163: forge.ExpectedPowerShelf.rack_id:type_name -> common.RackId + 1030, // 164: forge.ExpectedPowerShelf.expected_power_shelf_id:type_name -> common.UUID + 1030, // 165: forge.ExpectedPowerShelfRequest.expected_power_shelf_id:type_name -> common.UUID 222, // 166: forge.ExpectedPowerShelfList.expected_power_shelves:type_name -> forge.ExpectedPowerShelf 226, // 167: forge.LinkedExpectedPowerShelfList.expected_power_shelves:type_name -> forge.LinkedExpectedPowerShelf - 1026, // 168: forge.LinkedExpectedPowerShelf.power_shelf_id:type_name -> common.PowerShelfId - 1028, // 169: forge.LinkedExpectedPowerShelf.expected_power_shelf_id:type_name -> common.UUID - 1027, // 170: forge.LinkedExpectedPowerShelf.rack_id:type_name -> common.RackId + 1028, // 168: forge.LinkedExpectedPowerShelf.power_shelf_id:type_name -> common.PowerShelfId + 1030, // 169: forge.LinkedExpectedPowerShelf.expected_power_shelf_id:type_name -> common.UUID + 1029, // 170: forge.LinkedExpectedPowerShelf.rack_id:type_name -> common.RackId 228, // 171: forge.SwitchConfig.fabric_manager_config:type_name -> forge.FabricManagerConfig - 980, // 172: forge.FabricManagerConfig.config_map:type_name -> forge.FabricManagerConfig.ConfigMapEntry + 982, // 172: forge.FabricManagerConfig.config_map:type_name -> forge.FabricManagerConfig.ConfigMapEntry 11, // 173: forge.FabricManagerStatus.fabric_manager_state:type_name -> forge.FabricManagerState 364, // 174: forge.SwitchStatus.state_reason:type_name -> forge.ControllerStateReason 366, // 175: forge.SwitchStatus.state_sla:type_name -> forge.StateSla - 1025, // 176: forge.SwitchStatus.health:type_name -> health.HealthReport + 1027, // 176: forge.SwitchStatus.health:type_name -> health.HealthReport 363, // 177: forge.SwitchStatus.health_sources:type_name -> forge.HealthSourceOrigin 101, // 178: forge.SwitchStatus.lifecycle:type_name -> forge.LifecycleStatus 229, // 179: forge.SwitchStatus.fabric_manager_status_details:type_name -> forge.FabricManagerStatus - 1029, // 180: forge.Switch.id:type_name -> common.SwitchId + 1031, // 180: forge.Switch.id:type_name -> common.SwitchId 227, // 181: forge.Switch.config:type_name -> forge.SwitchConfig 230, // 182: forge.Switch.status:type_name -> forge.SwitchStatus - 1017, // 183: forge.Switch.deleted:type_name -> google.protobuf.Timestamp + 1019, // 183: forge.Switch.deleted:type_name -> google.protobuf.Timestamp 349, // 184: forge.Switch.bmc_info:type_name -> forge.BmcInfo 273, // 185: forge.Switch.metadata:type_name -> forge.Metadata - 1027, // 186: forge.Switch.rack_id:type_name -> common.RackId + 1029, // 186: forge.Switch.rack_id:type_name -> common.RackId 231, // 187: forge.Switch.placement_in_rack:type_name -> forge.PlacementInRack 350, // 188: forge.Switch.nvos_info:type_name -> forge.SwitchNvosInfo 232, // 189: forge.SwitchList.switches:type_name -> forge.Switch 227, // 190: forge.SwitchCreationRequest.config:type_name -> forge.SwitchConfig - 1028, // 191: forge.SwitchCreationRequest.id:type_name -> common.UUID + 1030, // 191: forge.SwitchCreationRequest.id:type_name -> common.UUID 231, // 192: forge.SwitchCreationRequest.placement_in_rack:type_name -> forge.PlacementInRack - 1029, // 193: forge.SwitchDeletionRequest.id:type_name -> common.SwitchId - 1017, // 194: forge.StateHistoryRecord.time:type_name -> google.protobuf.Timestamp + 1031, // 193: forge.SwitchDeletionRequest.id:type_name -> common.SwitchId + 1019, // 194: forge.StateHistoryRecord.time:type_name -> google.protobuf.Timestamp 237, // 195: forge.StateHistoryRecords.records:type_name -> forge.StateHistoryRecord - 1029, // 196: forge.SwitchStateHistoriesRequest.switch_ids:type_name -> common.SwitchId - 981, // 197: forge.StateHistories.histories:type_name -> forge.StateHistories.HistoriesEntry - 1029, // 198: forge.SwitchQuery.switch_id:type_name -> common.SwitchId - 1027, // 199: forge.SwitchSearchFilter.rack_id:type_name -> common.RackId + 1031, // 196: forge.SwitchStateHistoriesRequest.switch_ids:type_name -> common.SwitchId + 983, // 197: forge.StateHistories.histories:type_name -> forge.StateHistories.HistoriesEntry + 1031, // 198: forge.SwitchQuery.switch_id:type_name -> common.SwitchId + 1029, // 199: forge.SwitchSearchFilter.rack_id:type_name -> common.RackId 10, // 200: forge.SwitchSearchFilter.deleted:type_name -> forge.DeletedFilter - 1029, // 201: forge.SwitchesByIdsRequest.switch_ids:type_name -> common.SwitchId + 1031, // 201: forge.SwitchesByIdsRequest.switch_ids:type_name -> common.SwitchId 273, // 202: forge.ExpectedSwitch.metadata:type_name -> forge.Metadata - 1027, // 203: forge.ExpectedSwitch.rack_id:type_name -> common.RackId - 1028, // 204: forge.ExpectedSwitch.expected_switch_id:type_name -> common.UUID - 1028, // 205: forge.ExpectedSwitchRequest.expected_switch_id:type_name -> common.UUID + 1029, // 203: forge.ExpectedSwitch.rack_id:type_name -> common.RackId + 1030, // 204: forge.ExpectedSwitch.expected_switch_id:type_name -> common.UUID + 1030, // 205: forge.ExpectedSwitchRequest.expected_switch_id:type_name -> common.UUID 244, // 206: forge.ExpectedSwitchList.expected_switches:type_name -> forge.ExpectedSwitch 248, // 207: forge.LinkedExpectedSwitchList.expected_switches:type_name -> forge.LinkedExpectedSwitch - 1029, // 208: forge.LinkedExpectedSwitch.switch_id:type_name -> common.SwitchId - 1028, // 209: forge.LinkedExpectedSwitch.expected_switch_id:type_name -> common.UUID - 1027, // 210: forge.LinkedExpectedSwitch.rack_id:type_name -> common.RackId - 1027, // 211: forge.ExpectedRack.rack_id:type_name -> common.RackId - 1030, // 212: forge.ExpectedRack.rack_profile_id:type_name -> common.RackProfileId + 1031, // 208: forge.LinkedExpectedSwitch.switch_id:type_name -> common.SwitchId + 1030, // 209: forge.LinkedExpectedSwitch.expected_switch_id:type_name -> common.UUID + 1029, // 210: forge.LinkedExpectedSwitch.rack_id:type_name -> common.RackId + 1029, // 211: forge.ExpectedRack.rack_id:type_name -> common.RackId + 1032, // 212: forge.ExpectedRack.rack_profile_id:type_name -> common.RackProfileId 273, // 213: forge.ExpectedRack.metadata:type_name -> forge.Metadata 249, // 214: forge.ExpectedRackList.expected_racks:type_name -> forge.ExpectedRack - 1017, // 215: forge.NetworkSegmentStateHistory.time:type_name -> google.protobuf.Timestamp - 1018, // 216: forge.NetworkSegmentConfig.vpc_id:type_name -> common.VpcId - 1031, // 217: forge.NetworkSegmentConfig.subdomain_id:type_name -> common.DomainId + 1019, // 215: forge.NetworkSegmentStateHistory.time:type_name -> google.protobuf.Timestamp + 1020, // 216: forge.NetworkSegmentConfig.vpc_id:type_name -> common.VpcId + 1033, // 217: forge.NetworkSegmentConfig.subdomain_id:type_name -> common.DomainId 12, // 218: forge.NetworkSegmentConfig.segment_type:type_name -> forge.NetworkSegmentType 267, // 219: forge.NetworkSegmentConfig.prefixes:type_name -> forge.NetworkPrefix 13, // 220: forge.NetworkSegmentStatus.flags:type_name -> forge.NetworkSegmentFlag 101, // 221: forge.NetworkSegmentStatus.lifecycle:type_name -> forge.LifecycleStatus 8, // 222: forge.NetworkSegmentStatus.tenant_state:type_name -> forge.TenantState - 1032, // 223: forge.NetworkSegment.id:type_name -> common.NetworkSegmentId - 1018, // 224: forge.NetworkSegment.vpc_id:type_name -> common.VpcId - 1031, // 225: forge.NetworkSegment.subdomain_id:type_name -> common.DomainId + 1034, // 223: forge.NetworkSegment.id:type_name -> common.NetworkSegmentId + 1020, // 224: forge.NetworkSegment.vpc_id:type_name -> common.VpcId + 1033, // 225: forge.NetworkSegment.subdomain_id:type_name -> common.DomainId 267, // 226: forge.NetworkSegment.prefixes:type_name -> forge.NetworkPrefix - 1017, // 227: forge.NetworkSegment.created:type_name -> google.protobuf.Timestamp - 1017, // 228: forge.NetworkSegment.updated:type_name -> google.protobuf.Timestamp - 1017, // 229: forge.NetworkSegment.deleted:type_name -> google.protobuf.Timestamp + 1019, // 227: forge.NetworkSegment.created:type_name -> google.protobuf.Timestamp + 1019, // 228: forge.NetworkSegment.updated:type_name -> google.protobuf.Timestamp + 1019, // 229: forge.NetworkSegment.deleted:type_name -> google.protobuf.Timestamp 12, // 230: forge.NetworkSegment.segment_type:type_name -> forge.NetworkSegmentType 13, // 231: forge.NetworkSegment.flags:type_name -> forge.NetworkSegmentFlag 255, // 232: forge.NetworkSegment.config:type_name -> forge.NetworkSegmentConfig @@ -70554,37 +70653,37 @@ var file_nico_nico_proto_depIdxs = []int32{ 254, // 236: forge.NetworkSegment.history:type_name -> forge.NetworkSegmentStateHistory 364, // 237: forge.NetworkSegment.state_reason:type_name -> forge.ControllerStateReason 366, // 238: forge.NetworkSegment.state_sla:type_name -> forge.StateSla - 1018, // 239: forge.NetworkSegmentCreationRequest.vpc_id:type_name -> common.VpcId - 1031, // 240: forge.NetworkSegmentCreationRequest.subdomain_id:type_name -> common.DomainId + 1020, // 239: forge.NetworkSegmentCreationRequest.vpc_id:type_name -> common.VpcId + 1033, // 240: forge.NetworkSegmentCreationRequest.subdomain_id:type_name -> common.DomainId 267, // 241: forge.NetworkSegmentCreationRequest.prefixes:type_name -> forge.NetworkPrefix 12, // 242: forge.NetworkSegmentCreationRequest.segment_type:type_name -> forge.NetworkSegmentType - 1032, // 243: forge.NetworkSegmentCreationRequest.id:type_name -> common.NetworkSegmentId - 1032, // 244: forge.NetworkSegmentDeletionRequest.id:type_name -> common.NetworkSegmentId - 1032, // 245: forge.AttachNetworkSegmentToVpcRequest.network_segment_id:type_name -> common.NetworkSegmentId - 1018, // 246: forge.AttachNetworkSegmentToVpcRequest.vpc_id:type_name -> common.VpcId - 1032, // 247: forge.NetworkSegmentStateHistoriesRequest.network_segment_ids:type_name -> common.NetworkSegmentId - 1032, // 248: forge.NetworkSegmentIdList.network_segments_ids:type_name -> common.NetworkSegmentId - 1032, // 249: forge.NetworkSegmentsByIdsRequest.network_segments_ids:type_name -> common.NetworkSegmentId - 1033, // 250: forge.NetworkPrefix.id:type_name -> common.NetworkPrefixId + 1034, // 243: forge.NetworkSegmentCreationRequest.id:type_name -> common.NetworkSegmentId + 1034, // 244: forge.NetworkSegmentDeletionRequest.id:type_name -> common.NetworkSegmentId + 1034, // 245: forge.AttachNetworkSegmentToVpcRequest.network_segment_id:type_name -> common.NetworkSegmentId + 1020, // 246: forge.AttachNetworkSegmentToVpcRequest.vpc_id:type_name -> common.VpcId + 1034, // 247: forge.NetworkSegmentStateHistoriesRequest.network_segment_ids:type_name -> common.NetworkSegmentId + 1034, // 248: forge.NetworkSegmentIdList.network_segments_ids:type_name -> common.NetworkSegmentId + 1034, // 249: forge.NetworkSegmentsByIdsRequest.network_segments_ids:type_name -> common.NetworkSegmentId + 1035, // 250: forge.NetworkPrefix.id:type_name -> common.NetworkPrefixId 87, // 251: forge.InstancePowerRequest.operation:type_name -> forge.InstancePowerRequest.Operation - 1034, // 252: forge.InstancePowerRequest.instance_id:type_name -> common.InstanceId + 1036, // 252: forge.InstancePowerRequest.instance_id:type_name -> common.InstanceId 306, // 253: forge.InstanceList.instances:type_name -> forge.Instance 272, // 254: forge.Metadata.labels:type_name -> forge.Label 272, // 255: forge.InstanceSearchFilter.label:type_name -> forge.Label - 1034, // 256: forge.InstanceIdList.instance_ids:type_name -> common.InstanceId - 1034, // 257: forge.InstancesByIdsRequest.instance_ids:type_name -> common.InstanceId - 1016, // 258: forge.InstanceAllocationRequest.machine_id:type_name -> common.MachineId + 1036, // 256: forge.InstanceIdList.instance_ids:type_name -> common.InstanceId + 1036, // 257: forge.InstancesByIdsRequest.instance_ids:type_name -> common.InstanceId + 1018, // 258: forge.InstanceAllocationRequest.machine_id:type_name -> common.MachineId 286, // 259: forge.InstanceAllocationRequest.config:type_name -> forge.InstanceConfig - 1034, // 260: forge.InstanceAllocationRequest.instance_id:type_name -> common.InstanceId + 1036, // 260: forge.InstanceAllocationRequest.instance_id:type_name -> common.InstanceId 273, // 261: forge.InstanceAllocationRequest.metadata:type_name -> forge.Metadata 277, // 262: forge.BatchInstanceAllocationRequest.instance_requests:type_name -> forge.InstanceAllocationRequest 306, // 263: forge.BatchInstanceAllocationResponse.instances:type_name -> forge.Instance 14, // 264: forge.IpxeTemplateArtifact.cache_strategy:type_name -> forge.IpxeTemplateArtifactCacheStrategy - 1035, // 265: forge.IpxeTemplate.id:type_name -> common.IpxeTemplateId + 1037, // 265: forge.IpxeTemplate.id:type_name -> common.IpxeTemplateId 15, // 266: forge.IpxeTemplate.visibility:type_name -> forge.IpxeTemplateVisibility 285, // 267: forge.InstanceOperatingSystemConfig.ipxe:type_name -> forge.InlineIpxe - 1028, // 268: forge.InstanceOperatingSystemConfig.os_image_id:type_name -> common.UUID - 1036, // 269: forge.InstanceOperatingSystemConfig.operating_system_id:type_name -> common.OperatingSystemId + 1030, // 268: forge.InstanceOperatingSystemConfig.os_image_id:type_name -> common.UUID + 1038, // 269: forge.InstanceOperatingSystemConfig.operating_system_id:type_name -> common.OperatingSystemId 283, // 270: forge.InstanceConfig.tenant:type_name -> forge.TenantConfig 284, // 271: forge.InstanceConfig.os:type_name -> forge.InstanceOperatingSystemConfig 287, // 272: forge.InstanceConfig.network:type_name -> forge.InstanceNetworkConfig @@ -70594,16 +70693,16 @@ var file_nico_nico_proto_depIdxs = []int32{ 293, // 276: forge.InstanceConfig.spxconfig:type_name -> forge.InstanceSpxConfig 308, // 277: forge.InstanceNetworkConfig.interfaces:type_name -> forge.InstanceInterfaceConfig 288, // 278: forge.InstanceNetworkConfig.auto_config:type_name -> forge.InstanceNetworkAutoConfig - 1018, // 279: forge.InstanceNetworkAutoConfig.vpc_id:type_name -> common.VpcId + 1020, // 279: forge.InstanceNetworkAutoConfig.vpc_id:type_name -> common.VpcId 312, // 280: forge.InstanceInfinibandConfig.ib_interfaces:type_name -> forge.InstanceIBInterfaceConfig 290, // 281: forge.InstanceDpuExtensionServicesConfig.service_configs:type_name -> forge.InstanceDpuExtensionServiceConfig 317, // 282: forge.InstanceNVLinkConfig.gpu_configs:type_name -> forge.InstanceNVLinkGpuConfig 294, // 283: forge.InstanceSpxConfig.spx_attachments:type_name -> forge.InstanceSpxAttachment - 1037, // 284: forge.InstanceSpxAttachment.spx_partition_id:type_name -> common.SpxPartitionId + 1039, // 284: forge.InstanceSpxAttachment.spx_partition_id:type_name -> common.SpxPartitionId 16, // 285: forge.InstanceSpxAttachment.attachment_type:type_name -> forge.SpxAttachmentType - 1034, // 286: forge.InstanceOperatingSystemUpdateRequest.instance_id:type_name -> common.InstanceId + 1036, // 286: forge.InstanceOperatingSystemUpdateRequest.instance_id:type_name -> common.InstanceId 284, // 287: forge.InstanceOperatingSystemUpdateRequest.os:type_name -> forge.InstanceOperatingSystemConfig - 1034, // 288: forge.InstanceConfigUpdateRequest.instance_id:type_name -> common.InstanceId + 1036, // 288: forge.InstanceConfigUpdateRequest.instance_id:type_name -> common.InstanceId 286, // 289: forge.InstanceConfigUpdateRequest.config:type_name -> forge.InstanceConfig 273, // 290: forge.InstanceConfigUpdateRequest.metadata:type_name -> forge.Metadata 367, // 291: forge.InstanceStatus.tenant:type_name -> forge.InstanceTenantStatus @@ -70617,12 +70716,12 @@ var file_nico_nico_proto_depIdxs = []int32{ 299, // 299: forge.InstanceSpxStatus.attachment_statuses:type_name -> forge.InstanceSpxAttachmentStatus 24, // 300: forge.InstanceSpxStatus.configs_synced:type_name -> forge.SyncState 16, // 301: forge.InstanceSpxAttachmentStatus.attachment_type:type_name -> forge.SpxAttachmentType - 1037, // 302: forge.InstanceSpxAttachmentStatus.spx_partition_id:type_name -> common.SpxPartitionId + 1039, // 302: forge.InstanceSpxAttachmentStatus.spx_partition_id:type_name -> common.SpxPartitionId 314, // 303: forge.InstanceNetworkStatus.interfaces:type_name -> forge.InstanceInterfaceStatus 24, // 304: forge.InstanceNetworkStatus.configs_synced:type_name -> forge.SyncState 315, // 305: forge.InstanceInfinibandStatus.ib_interfaces:type_name -> forge.InstanceIBInterfaceStatus 24, // 306: forge.InstanceInfinibandStatus.configs_synced:type_name -> forge.SyncState - 1016, // 307: forge.DpuExtensionServiceStatus.dpu_machine_id:type_name -> common.MachineId + 1018, // 307: forge.DpuExtensionServiceStatus.dpu_machine_id:type_name -> common.MachineId 74, // 308: forge.DpuExtensionServiceStatus.status:type_name -> forge.DpuExtensionServiceDeploymentStatus 464, // 309: forge.DpuExtensionServiceStatus.components:type_name -> forge.DpuExtensionServiceComponent 74, // 310: forge.InstanceDpuExtensionServiceStatus.deployment_status:type_name -> forge.DpuExtensionServiceDeploymentStatus @@ -70631,220 +70730,220 @@ var file_nico_nico_proto_depIdxs = []int32{ 24, // 313: forge.InstanceDpuExtensionServicesStatus.configs_synced:type_name -> forge.SyncState 316, // 314: forge.InstanceNVLinkStatus.gpu_statuses:type_name -> forge.InstanceNVLinkGpuStatus 24, // 315: forge.InstanceNVLinkStatus.configs_synced:type_name -> forge.SyncState - 1034, // 316: forge.Instance.id:type_name -> common.InstanceId - 1016, // 317: forge.Instance.machine_id:type_name -> common.MachineId + 1036, // 316: forge.Instance.id:type_name -> common.InstanceId + 1018, // 317: forge.Instance.machine_id:type_name -> common.MachineId 273, // 318: forge.Instance.metadata:type_name -> forge.Metadata 286, // 319: forge.Instance.config:type_name -> forge.InstanceConfig 297, // 320: forge.Instance.status:type_name -> forge.InstanceStatus 88, // 321: forge.InstanceUpdateStatus.module:type_name -> forge.InstanceUpdateStatus.Module - 1017, // 322: forge.InstanceUpdateStatus.trigger_received_at:type_name -> google.protobuf.Timestamp - 1017, // 323: forge.InstanceUpdateStatus.update_triggered_at:type_name -> google.protobuf.Timestamp + 1019, // 322: forge.InstanceUpdateStatus.trigger_received_at:type_name -> google.protobuf.Timestamp + 1019, // 323: forge.InstanceUpdateStatus.update_triggered_at:type_name -> google.protobuf.Timestamp 40, // 324: forge.InstanceInterfaceConfig.function_type:type_name -> forge.InterfaceFunctionType - 1032, // 325: forge.InstanceInterfaceConfig.network_segment_id:type_name -> common.NetworkSegmentId - 1032, // 326: forge.InstanceInterfaceConfig.segment_id:type_name -> common.NetworkSegmentId - 1022, // 327: forge.InstanceInterfaceConfig.vpc_prefix_id:type_name -> common.VpcPrefixId + 1034, // 325: forge.InstanceInterfaceConfig.network_segment_id:type_name -> common.NetworkSegmentId + 1034, // 326: forge.InstanceInterfaceConfig.segment_id:type_name -> common.NetworkSegmentId + 1024, // 327: forge.InstanceInterfaceConfig.vpc_prefix_id:type_name -> common.VpcPrefixId 309, // 328: forge.InstanceInterfaceConfig.vpc:type_name -> forge.InstanceInterfaceVpcSelection 310, // 329: forge.InstanceInterfaceConfig.ipv6_interface_config:type_name -> forge.InstanceInterfaceIpv6Config 311, // 330: forge.InstanceInterfaceConfig.routing_profile:type_name -> forge.InstanceInterfaceRoutingProfile - 1018, // 331: forge.InstanceInterfaceVpcSelection.vpc_id:type_name -> common.VpcId + 1020, // 331: forge.InstanceInterfaceVpcSelection.vpc_id:type_name -> common.VpcId 17, // 332: forge.InstanceInterfaceVpcSelection.family_mode:type_name -> forge.InstanceInterfaceIpFamilyMode - 1022, // 333: forge.InstanceInterfaceIpv6Config.vpc_prefix_id:type_name -> common.VpcPrefixId - 887, // 334: forge.InstanceInterfaceRoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry + 1024, // 333: forge.InstanceInterfaceIpv6Config.vpc_prefix_id:type_name -> common.VpcPrefixId + 889, // 334: forge.InstanceInterfaceRoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry 40, // 335: forge.InstanceIBInterfaceConfig.function_type:type_name -> forge.InterfaceFunctionType - 1024, // 336: forge.InstanceIBInterfaceConfig.ib_partition_id:type_name -> common.IBPartitionId - 1022, // 337: forge.InstanceInterfaceResolvedVpcPrefixes.ipv4_vpc_prefix_id:type_name -> common.VpcPrefixId - 1022, // 338: forge.InstanceInterfaceResolvedVpcPrefixes.ipv6_vpc_prefix_id:type_name -> common.VpcPrefixId - 1018, // 339: forge.InstanceInterfaceStatus.vpc_id:type_name -> common.VpcId + 1026, // 336: forge.InstanceIBInterfaceConfig.ib_partition_id:type_name -> common.IBPartitionId + 1024, // 337: forge.InstanceInterfaceResolvedVpcPrefixes.ipv4_vpc_prefix_id:type_name -> common.VpcPrefixId + 1024, // 338: forge.InstanceInterfaceResolvedVpcPrefixes.ipv6_vpc_prefix_id:type_name -> common.VpcPrefixId + 1020, // 339: forge.InstanceInterfaceStatus.vpc_id:type_name -> common.VpcId 313, // 340: forge.InstanceInterfaceStatus.resolved_vpc_prefixes:type_name -> forge.InstanceInterfaceResolvedVpcPrefixes - 1038, // 341: forge.InstanceNVLinkGpuStatus.domain_id:type_name -> common.NVLinkDomainId - 1021, // 342: forge.InstanceNVLinkGpuStatus.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId - 1021, // 343: forge.InstanceNVLinkGpuConfig.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId - 1034, // 344: forge.InstancePhoneHomeLastContactRequest.instance_id:type_name -> common.InstanceId - 1017, // 345: forge.InstancePhoneHomeLastContactResponse.timestamp:type_name -> google.protobuf.Timestamp + 1040, // 341: forge.InstanceNVLinkGpuStatus.domain_id:type_name -> common.NVLinkDomainId + 1023, // 342: forge.InstanceNVLinkGpuStatus.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 343: forge.InstanceNVLinkGpuConfig.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1036, // 344: forge.InstancePhoneHomeLastContactRequest.instance_id:type_name -> common.InstanceId + 1019, // 345: forge.InstancePhoneHomeLastContactResponse.timestamp:type_name -> google.protobuf.Timestamp 18, // 346: forge.Issue.category:type_name -> forge.IssueCategory 321, // 347: forge.DeleteAttribution.initiated_by:type_name -> forge.DeleteInitiatedBy - 1034, // 348: forge.InstanceReleaseRequest.id:type_name -> common.InstanceId + 1036, // 348: forge.InstanceReleaseRequest.id:type_name -> common.InstanceId 320, // 349: forge.InstanceReleaseRequest.issue:type_name -> forge.Issue 322, // 350: forge.InstanceReleaseRequest.delete_attribution:type_name -> forge.DeleteAttribution - 1016, // 351: forge.MachinesByIdsRequest.machine_ids:type_name -> common.MachineId - 1027, // 352: forge.MachineSearchConfig.rack_id:type_name -> common.RackId - 1016, // 353: forge.MachineStateHistoriesRequest.machine_ids:type_name -> common.MachineId - 982, // 354: forge.MachineStateHistories.histories:type_name -> forge.MachineStateHistories.HistoriesEntry + 1018, // 351: forge.MachinesByIdsRequest.machine_ids:type_name -> common.MachineId + 1029, // 352: forge.MachineSearchConfig.rack_id:type_name -> common.RackId + 1018, // 353: forge.MachineStateHistoriesRequest.machine_ids:type_name -> common.MachineId + 984, // 354: forge.MachineStateHistories.histories:type_name -> forge.MachineStateHistories.HistoriesEntry 368, // 355: forge.MachineStateHistoryRecords.records:type_name -> forge.MachineEvent - 1016, // 356: forge.MachineHealthHistoriesRequest.machine_ids:type_name -> common.MachineId - 1017, // 357: forge.MachineHealthHistoriesRequest.start_time:type_name -> google.protobuf.Timestamp - 1017, // 358: forge.MachineHealthHistoriesRequest.end_time:type_name -> google.protobuf.Timestamp - 983, // 359: forge.HealthHistories.histories:type_name -> forge.HealthHistories.HistoriesEntry + 1018, // 356: forge.MachineHealthHistoriesRequest.machine_ids:type_name -> common.MachineId + 1019, // 357: forge.MachineHealthHistoriesRequest.start_time:type_name -> google.protobuf.Timestamp + 1019, // 358: forge.MachineHealthHistoriesRequest.end_time:type_name -> google.protobuf.Timestamp + 985, // 359: forge.HealthHistories.histories:type_name -> forge.HealthHistories.HistoriesEntry 333, // 360: forge.HealthHistoryRecords.records:type_name -> forge.HealthHistoryRecord - 1025, // 361: forge.HealthHistoryRecord.health:type_name -> health.HealthReport - 1017, // 362: forge.HealthHistoryRecord.time:type_name -> google.protobuf.Timestamp + 1027, // 361: forge.HealthHistoryRecord.health:type_name -> health.HealthReport + 1019, // 362: forge.HealthHistoryRecord.time:type_name -> google.protobuf.Timestamp 485, // 363: forge.TenantList.tenants:type_name -> forge.Tenant 369, // 364: forge.InterfaceList.interfaces:type_name -> forge.MachineInterface 353, // 365: forge.MachineList.machines:type_name -> forge.Machine - 1039, // 366: forge.InterfaceDeleteQuery.id:type_name -> common.MachineInterfaceId - 1039, // 367: forge.InterfaceSearchQuery.id:type_name -> common.MachineInterfaceId - 1039, // 368: forge.AssignStaticAddressRequest.interface_id:type_name -> common.MachineInterfaceId - 1039, // 369: forge.AssignStaticAddressResponse.interface_id:type_name -> common.MachineInterfaceId + 1041, // 366: forge.InterfaceDeleteQuery.id:type_name -> common.MachineInterfaceId + 1041, // 367: forge.InterfaceSearchQuery.id:type_name -> common.MachineInterfaceId + 1041, // 368: forge.AssignStaticAddressRequest.interface_id:type_name -> common.MachineInterfaceId + 1041, // 369: forge.AssignStaticAddressResponse.interface_id:type_name -> common.MachineInterfaceId 19, // 370: forge.AssignStaticAddressResponse.status:type_name -> forge.AssignStaticAddressStatus - 1039, // 371: forge.RemoveStaticAddressRequest.interface_id:type_name -> common.MachineInterfaceId - 1039, // 372: forge.RemoveStaticAddressResponse.interface_id:type_name -> common.MachineInterfaceId + 1041, // 371: forge.RemoveStaticAddressRequest.interface_id:type_name -> common.MachineInterfaceId + 1041, // 372: forge.RemoveStaticAddressResponse.interface_id:type_name -> common.MachineInterfaceId 20, // 373: forge.RemoveStaticAddressResponse.status:type_name -> forge.RemoveStaticAddressStatus - 1039, // 374: forge.FindInterfaceAddressesRequest.interface_id:type_name -> common.MachineInterfaceId - 1039, // 375: forge.FindInterfaceAddressesResponse.interface_id:type_name -> common.MachineInterfaceId + 1041, // 374: forge.FindInterfaceAddressesRequest.interface_id:type_name -> common.MachineInterfaceId + 1041, // 375: forge.FindInterfaceAddressesResponse.interface_id:type_name -> common.MachineInterfaceId 347, // 376: forge.FindInterfaceAddressesResponse.addresses:type_name -> forge.InterfaceAddress - 1039, // 377: forge.BmcInfo.machine_interface_id:type_name -> common.MachineInterfaceId - 1017, // 378: forge.MachineConfig.maintenance_start_time:type_name -> google.protobuf.Timestamp + 1041, // 377: forge.BmcInfo.machine_interface_id:type_name -> common.MachineInterfaceId + 1019, // 378: forge.MachineConfig.maintenance_start_time:type_name -> google.protobuf.Timestamp 354, // 379: forge.MachineConfig.dpf:type_name -> forge.DpfMachineState 369, // 380: forge.MachineStatus.interfaces:type_name -> forge.MachineInterface - 1040, // 381: forge.MachineStatus.discovery_info:type_name -> machine_discovery.DiscoveryInfo - 1017, // 382: forge.MachineStatus.last_reboot_time:type_name -> google.protobuf.Timestamp - 1017, // 383: forge.MachineStatus.last_observation_time:type_name -> google.protobuf.Timestamp - 1016, // 384: forge.MachineStatus.associated_host_machine_id:type_name -> common.MachineId - 1016, // 385: forge.MachineStatus.associated_dpu_machine_ids:type_name -> common.MachineId - 1017, // 386: forge.MachineStatus.last_reboot_requested_time:type_name -> google.protobuf.Timestamp - 1025, // 387: forge.MachineStatus.health:type_name -> health.HealthReport + 1042, // 381: forge.MachineStatus.discovery_info:type_name -> machine_discovery.DiscoveryInfo + 1019, // 382: forge.MachineStatus.last_reboot_time:type_name -> google.protobuf.Timestamp + 1019, // 383: forge.MachineStatus.last_observation_time:type_name -> google.protobuf.Timestamp + 1018, // 384: forge.MachineStatus.associated_host_machine_id:type_name -> common.MachineId + 1018, // 385: forge.MachineStatus.associated_dpu_machine_ids:type_name -> common.MachineId + 1019, // 386: forge.MachineStatus.last_reboot_requested_time:type_name -> google.protobuf.Timestamp + 1027, // 387: forge.MachineStatus.health:type_name -> health.HealthReport 363, // 388: forge.MachineStatus.health_sources:type_name -> forge.HealthSourceOrigin 370, // 389: forge.MachineStatus.infiniband:type_name -> forge.InfinibandStatusObservation - 649, // 390: forge.MachineStatus.capabilities:type_name -> forge.MachineCapabilitiesSet - 722, // 391: forge.MachineStatus.hw_sku:type_name -> forge.SkuStatus + 651, // 390: forge.MachineStatus.capabilities:type_name -> forge.MachineCapabilitiesSet + 724, // 391: forge.MachineStatus.hw_sku:type_name -> forge.SkuStatus 401, // 392: forge.MachineStatus.quarantine:type_name -> forge.ManagedHostQuarantineState - 773, // 393: forge.MachineStatus.nvlink_info:type_name -> forge.MachineNVLinkInfo - 783, // 394: forge.MachineStatus.nvlink:type_name -> forge.MachineNVLinkStatusObservation - 775, // 395: forge.MachineStatus.spx:type_name -> forge.MachineSpxStatusObservation + 775, // 393: forge.MachineStatus.nvlink_info:type_name -> forge.MachineNVLinkInfo + 785, // 394: forge.MachineStatus.nvlink:type_name -> forge.MachineNVLinkStatusObservation + 777, // 395: forge.MachineStatus.spx:type_name -> forge.MachineSpxStatusObservation 355, // 396: forge.MachineStatus.instance_network_restrictions:type_name -> forge.InstanceNetworkRestrictions 101, // 397: forge.MachineStatus.lifecycle:type_name -> forge.LifecycleStatus - 1016, // 398: forge.Machine.id:type_name -> common.MachineId + 1018, // 398: forge.Machine.id:type_name -> common.MachineId 364, // 399: forge.Machine.state_reason:type_name -> forge.ControllerStateReason 366, // 400: forge.Machine.state_sla:type_name -> forge.StateSla 368, // 401: forge.Machine.events:type_name -> forge.MachineEvent 369, // 402: forge.Machine.interfaces:type_name -> forge.MachineInterface - 1040, // 403: forge.Machine.discovery_info:type_name -> machine_discovery.DiscoveryInfo + 1042, // 403: forge.Machine.discovery_info:type_name -> machine_discovery.DiscoveryInfo 21, // 404: forge.Machine.machine_type:type_name -> forge.MachineType 349, // 405: forge.Machine.bmc_info:type_name -> forge.BmcInfo - 1017, // 406: forge.Machine.last_reboot_time:type_name -> google.protobuf.Timestamp - 1017, // 407: forge.Machine.last_observation_time:type_name -> google.protobuf.Timestamp - 1017, // 408: forge.Machine.maintenance_start_time:type_name -> google.protobuf.Timestamp - 1016, // 409: forge.Machine.associated_host_machine_id:type_name -> common.MachineId + 1019, // 406: forge.Machine.last_reboot_time:type_name -> google.protobuf.Timestamp + 1019, // 407: forge.Machine.last_observation_time:type_name -> google.protobuf.Timestamp + 1019, // 408: forge.Machine.maintenance_start_time:type_name -> google.protobuf.Timestamp + 1018, // 409: forge.Machine.associated_host_machine_id:type_name -> common.MachineId 361, // 410: forge.Machine.inventory:type_name -> forge.MachineComponentInventory - 1017, // 411: forge.Machine.last_reboot_requested_time:type_name -> google.protobuf.Timestamp - 1016, // 412: forge.Machine.associated_dpu_machine_ids:type_name -> common.MachineId - 1025, // 413: forge.Machine.health:type_name -> health.HealthReport + 1019, // 411: forge.Machine.last_reboot_requested_time:type_name -> google.protobuf.Timestamp + 1018, // 412: forge.Machine.associated_dpu_machine_ids:type_name -> common.MachineId + 1027, // 413: forge.Machine.health:type_name -> health.HealthReport 363, // 414: forge.Machine.health_sources:type_name -> forge.HealthSourceOrigin 370, // 415: forge.Machine.ib_status:type_name -> forge.InfinibandStatusObservation 273, // 416: forge.Machine.metadata:type_name -> forge.Metadata 355, // 417: forge.Machine.instance_network_restrictions:type_name -> forge.InstanceNetworkRestrictions - 649, // 418: forge.Machine.capabilities:type_name -> forge.MachineCapabilitiesSet - 722, // 419: forge.Machine.hw_sku_status:type_name -> forge.SkuStatus + 651, // 418: forge.Machine.capabilities:type_name -> forge.MachineCapabilitiesSet + 724, // 419: forge.Machine.hw_sku_status:type_name -> forge.SkuStatus 401, // 420: forge.Machine.quarantine_state:type_name -> forge.ManagedHostQuarantineState - 773, // 421: forge.Machine.nvlink_info:type_name -> forge.MachineNVLinkInfo - 783, // 422: forge.Machine.nvlink_status_observation:type_name -> forge.MachineNVLinkStatusObservation - 1027, // 423: forge.Machine.rack_id:type_name -> common.RackId + 775, // 421: forge.Machine.nvlink_info:type_name -> forge.MachineNVLinkInfo + 785, // 422: forge.Machine.nvlink_status_observation:type_name -> forge.MachineNVLinkStatusObservation + 1029, // 423: forge.Machine.rack_id:type_name -> common.RackId 231, // 424: forge.Machine.placement_in_rack:type_name -> forge.PlacementInRack - 775, // 425: forge.Machine.spx_status_observation:type_name -> forge.MachineSpxStatusObservation + 777, // 425: forge.Machine.spx_status_observation:type_name -> forge.MachineSpxStatusObservation 354, // 426: forge.Machine.dpf:type_name -> forge.DpfMachineState 351, // 427: forge.Machine.config:type_name -> forge.MachineConfig 352, // 428: forge.Machine.status:type_name -> forge.MachineStatus 22, // 429: forge.InstanceNetworkRestrictions.network_segment_membership_type:type_name -> forge.InstanceNetworkSegmentMembershipType - 1032, // 430: forge.InstanceNetworkRestrictions.network_segment_ids:type_name -> common.NetworkSegmentId - 1016, // 431: forge.MachineMetadataUpdateRequest.machine_id:type_name -> common.MachineId + 1034, // 430: forge.InstanceNetworkRestrictions.network_segment_ids:type_name -> common.NetworkSegmentId + 1018, // 431: forge.MachineMetadataUpdateRequest.machine_id:type_name -> common.MachineId 273, // 432: forge.MachineMetadataUpdateRequest.metadata:type_name -> forge.Metadata - 1027, // 433: forge.RackMetadataUpdateRequest.rack_id:type_name -> common.RackId + 1029, // 433: forge.RackMetadataUpdateRequest.rack_id:type_name -> common.RackId 273, // 434: forge.RackMetadataUpdateRequest.metadata:type_name -> forge.Metadata - 1029, // 435: forge.SwitchMetadataUpdateRequest.switch_id:type_name -> common.SwitchId + 1031, // 435: forge.SwitchMetadataUpdateRequest.switch_id:type_name -> common.SwitchId 273, // 436: forge.SwitchMetadataUpdateRequest.metadata:type_name -> forge.Metadata - 1026, // 437: forge.PowerShelfMetadataUpdateRequest.power_shelf_id:type_name -> common.PowerShelfId + 1028, // 437: forge.PowerShelfMetadataUpdateRequest.power_shelf_id:type_name -> common.PowerShelfId 273, // 438: forge.PowerShelfMetadataUpdateRequest.metadata:type_name -> forge.Metadata - 1016, // 439: forge.DpuAgentInventoryReport.machine_id:type_name -> common.MachineId + 1018, // 439: forge.DpuAgentInventoryReport.machine_id:type_name -> common.MachineId 361, // 440: forge.DpuAgentInventoryReport.inventory:type_name -> forge.MachineComponentInventory 362, // 441: forge.MachineComponentInventory.components:type_name -> forge.MachineInventorySoftwareComponent 41, // 442: forge.HealthSourceOrigin.mode:type_name -> forge.HealthReportApplyMode 23, // 443: forge.ControllerStateReason.outcome:type_name -> forge.ControllerStateOutcome 365, // 444: forge.ControllerStateReason.source_ref:type_name -> forge.ControllerStateSourceReference - 1041, // 445: forge.StateSla.sla:type_name -> google.protobuf.Duration + 1043, // 445: forge.StateSla.sla:type_name -> google.protobuf.Duration 8, // 446: forge.InstanceTenantStatus.state:type_name -> forge.TenantState - 1017, // 447: forge.MachineEvent.time:type_name -> google.protobuf.Timestamp - 1039, // 448: forge.MachineInterface.id:type_name -> common.MachineInterfaceId - 1016, // 449: forge.MachineInterface.attached_dpu_machine_id:type_name -> common.MachineId - 1016, // 450: forge.MachineInterface.machine_id:type_name -> common.MachineId - 1032, // 451: forge.MachineInterface.segment_id:type_name -> common.NetworkSegmentId - 1031, // 452: forge.MachineInterface.domain_id:type_name -> common.DomainId - 1017, // 453: forge.MachineInterface.created:type_name -> google.protobuf.Timestamp - 1017, // 454: forge.MachineInterface.last_dhcp:type_name -> google.protobuf.Timestamp - 1026, // 455: forge.MachineInterface.power_shelf_id:type_name -> common.PowerShelfId - 1029, // 456: forge.MachineInterface.switch_id:type_name -> common.SwitchId + 1019, // 447: forge.MachineEvent.time:type_name -> google.protobuf.Timestamp + 1041, // 448: forge.MachineInterface.id:type_name -> common.MachineInterfaceId + 1018, // 449: forge.MachineInterface.attached_dpu_machine_id:type_name -> common.MachineId + 1018, // 450: forge.MachineInterface.machine_id:type_name -> common.MachineId + 1034, // 451: forge.MachineInterface.segment_id:type_name -> common.NetworkSegmentId + 1033, // 452: forge.MachineInterface.domain_id:type_name -> common.DomainId + 1019, // 453: forge.MachineInterface.created:type_name -> google.protobuf.Timestamp + 1019, // 454: forge.MachineInterface.last_dhcp:type_name -> google.protobuf.Timestamp + 1028, // 455: forge.MachineInterface.power_shelf_id:type_name -> common.PowerShelfId + 1031, // 456: forge.MachineInterface.switch_id:type_name -> common.SwitchId 26, // 457: forge.MachineInterface.association_type:type_name -> forge.InterfaceAssociationType 27, // 458: forge.MachineInterface.interface_type:type_name -> forge.InterfaceType 371, // 459: forge.InfinibandStatusObservation.ib_interfaces:type_name -> forge.MachineIbInterface - 1017, // 460: forge.InfinibandStatusObservation.observed_at:type_name -> google.protobuf.Timestamp - 1042, // 461: forge.MachineIbInterface.associated_pkeys:type_name -> common.StringList - 1042, // 462: forge.MachineIbInterface.associated_partition_ids:type_name -> common.StringList + 1019, // 460: forge.InfinibandStatusObservation.observed_at:type_name -> google.protobuf.Timestamp + 1044, // 461: forge.MachineIbInterface.associated_pkeys:type_name -> common.StringList + 1044, // 462: forge.MachineIbInterface.associated_partition_ids:type_name -> common.StringList 28, // 463: forge.DhcpDiscovery.address_family:type_name -> forge.AddressFamily 29, // 464: forge.DhcpDiscovery.message_kind:type_name -> forge.MessageKind 30, // 465: forge.ExpireDhcpLeaseResponse.status:type_name -> forge.ExpireDhcpLeaseStatus - 1016, // 466: forge.DhcpRecord.machine_id:type_name -> common.MachineId - 1039, // 467: forge.DhcpRecord.machine_interface_id:type_name -> common.MachineInterfaceId - 1032, // 468: forge.DhcpRecord.segment_id:type_name -> common.NetworkSegmentId - 1031, // 469: forge.DhcpRecord.subdomain_id:type_name -> common.DomainId - 1017, // 470: forge.DhcpRecord.last_invalidation_time:type_name -> google.protobuf.Timestamp + 1018, // 466: forge.DhcpRecord.machine_id:type_name -> common.MachineId + 1041, // 467: forge.DhcpRecord.machine_interface_id:type_name -> common.MachineInterfaceId + 1034, // 468: forge.DhcpRecord.segment_id:type_name -> common.NetworkSegmentId + 1033, // 469: forge.DhcpRecord.subdomain_id:type_name -> common.DomainId + 1019, // 470: forge.DhcpRecord.last_invalidation_time:type_name -> google.protobuf.Timestamp 257, // 471: forge.NetworkSegmentList.network_segments:type_name -> forge.NetworkSegment 31, // 472: forge.SSHKeyValidationResponse.role:type_name -> forge.UserRoles - 1029, // 473: forge.GetSwitchNvosCredentialsRequest.switch_id:type_name -> common.SwitchId + 1031, // 473: forge.GetSwitchNvosCredentialsRequest.switch_id:type_name -> common.SwitchId 382, // 474: forge.GetBmcCredentialsResponse.credentials:type_name -> forge.BmcCredentials - 852, // 475: forge.BmcCredentials.username_password:type_name -> forge.UsernamePassword - 853, // 476: forge.BmcCredentials.session_token:type_name -> forge.SessionToken + 854, // 475: forge.BmcCredentials.username_password:type_name -> forge.UsernamePassword + 855, // 476: forge.BmcCredentials.session_token:type_name -> forge.SessionToken 390, // 477: forge.SshRequest.endpoint_request:type_name -> forge.BmcEndpointRequest 392, // 478: forge.CopyBfbToDpuRshimRequest.ssh_request:type_name -> forge.SshRequest - 1016, // 479: forge.UpdateMachineHardwareInfoRequest.machine_id:type_name -> common.MachineId + 1018, // 479: forge.UpdateMachineHardwareInfoRequest.machine_id:type_name -> common.MachineId 395, // 480: forge.UpdateMachineHardwareInfoRequest.info:type_name -> forge.MachineHardwareInfo 32, // 481: forge.UpdateMachineHardwareInfoRequest.update_type:type_name -> forge.MachineHardwareInfoUpdateType - 1043, // 482: forge.MachineHardwareInfo.gpus:type_name -> machine_discovery.Gpu - 1016, // 483: forge.ManagedHostNetworkConfigRequest.dpu_machine_id:type_name -> common.MachineId + 1045, // 482: forge.MachineHardwareInfo.gpus:type_name -> machine_discovery.Gpu + 1018, // 483: forge.ManagedHostNetworkConfigRequest.dpu_machine_id:type_name -> common.MachineId 408, // 484: forge.ManagedHostNetworkConfigResponse.managed_host_config:type_name -> forge.ManagedHostNetworkConfig 409, // 485: forge.ManagedHostNetworkConfigResponse.admin_interface:type_name -> forge.FlatInterfaceConfig 409, // 486: forge.ManagedHostNetworkConfigResponse.tenant_interfaces:type_name -> forge.FlatInterfaceConfig - 1034, // 487: forge.ManagedHostNetworkConfigResponse.instance_id:type_name -> common.InstanceId + 1036, // 487: forge.ManagedHostNetworkConfigResponse.instance_id:type_name -> common.InstanceId 6, // 488: forge.ManagedHostNetworkConfigResponse.network_virtualization_type:type_name -> forge.VpcVirtualizationType 34, // 489: forge.ManagedHostNetworkConfigResponse.vpc_isolation_behavior:type_name -> forge.VpcIsolationBehaviorType 306, // 490: forge.ManagedHostNetworkConfigResponse.instance:type_name -> forge.Instance - 1020, // 491: forge.ManagedHostNetworkConfigResponse.common_internal_route_target:type_name -> common.RouteTarget - 1020, // 492: forge.ManagedHostNetworkConfigResponse.additional_route_target_imports:type_name -> common.RouteTarget - 700, // 493: forge.ManagedHostNetworkConfigResponse.network_security_policy_overrides:type_name -> forge.ResolvedNetworkSecurityGroupRule + 1022, // 491: forge.ManagedHostNetworkConfigResponse.common_internal_route_target:type_name -> common.RouteTarget + 1022, // 492: forge.ManagedHostNetworkConfigResponse.additional_route_target_imports:type_name -> common.RouteTarget + 702, // 493: forge.ManagedHostNetworkConfigResponse.network_security_policy_overrides:type_name -> forge.ResolvedNetworkSecurityGroupRule 400, // 494: forge.ManagedHostNetworkConfigResponse.dpu_extension_services:type_name -> forge.ManagedHostDpuExtensionServiceConfig 398, // 495: forge.ManagedHostNetworkConfigResponse.traffic_intercept_config:type_name -> forge.TrafficInterceptConfig - 888, // 496: forge.ManagedHostNetworkConfigResponse.routing_profile:type_name -> forge.RoutingProfile - 777, // 497: forge.ManagedHostNetworkConfigResponse.astra_config:type_name -> forge.AstraConfig + 890, // 496: forge.ManagedHostNetworkConfigResponse.routing_profile:type_name -> forge.RoutingProfile + 779, // 497: forge.ManagedHostNetworkConfigResponse.astra_config:type_name -> forge.AstraConfig 399, // 498: forge.TrafficInterceptConfig.bridging:type_name -> forge.TrafficInterceptBridging - 984, // 499: forge.TrafficInterceptBridging.host_representor_intercept_bridging:type_name -> forge.TrafficInterceptBridging.HostRepresentorInterceptBridgingEntry + 986, // 499: forge.TrafficInterceptBridging.host_representor_intercept_bridging:type_name -> forge.TrafficInterceptBridging.HostRepresentorInterceptBridgingEntry 73, // 500: forge.ManagedHostDpuExtensionServiceConfig.service_type:type_name -> forge.DpuExtensionServiceType - 854, // 501: forge.ManagedHostDpuExtensionServiceConfig.credential:type_name -> forge.DpuExtensionServiceCredential - 873, // 502: forge.ManagedHostDpuExtensionServiceConfig.observability:type_name -> forge.DpuExtensionServiceObservability + 856, // 501: forge.ManagedHostDpuExtensionServiceConfig.credential:type_name -> forge.DpuExtensionServiceCredential + 875, // 502: forge.ManagedHostDpuExtensionServiceConfig.observability:type_name -> forge.DpuExtensionServiceObservability 33, // 503: forge.ManagedHostQuarantineState.mode:type_name -> forge.ManagedHostQuarantineMode - 1016, // 504: forge.GetManagedHostQuarantineStateRequest.machine_id:type_name -> common.MachineId + 1018, // 504: forge.GetManagedHostQuarantineStateRequest.machine_id:type_name -> common.MachineId 401, // 505: forge.GetManagedHostQuarantineStateResponse.quarantine_state:type_name -> forge.ManagedHostQuarantineState - 1016, // 506: forge.SetManagedHostQuarantineStateRequest.machine_id:type_name -> common.MachineId + 1018, // 506: forge.SetManagedHostQuarantineStateRequest.machine_id:type_name -> common.MachineId 401, // 507: forge.SetManagedHostQuarantineStateRequest.quarantine_state:type_name -> forge.ManagedHostQuarantineState 401, // 508: forge.SetManagedHostQuarantineStateResponse.prior_quarantine_state:type_name -> forge.ManagedHostQuarantineState - 1016, // 509: forge.ClearManagedHostQuarantineStateRequest.machine_id:type_name -> common.MachineId + 1018, // 509: forge.ClearManagedHostQuarantineStateRequest.machine_id:type_name -> common.MachineId 401, // 510: forge.ClearManagedHostQuarantineStateResponse.prior_quarantine_state:type_name -> forge.ManagedHostQuarantineState 401, // 511: forge.ManagedHostNetworkConfig.quarantine_state:type_name -> forge.ManagedHostQuarantineState 40, // 512: forge.FlatInterfaceConfig.function_type:type_name -> forge.InterfaceFunctionType 411, // 513: forge.FlatInterfaceConfig.ipv6_interface_config:type_name -> forge.FlatInterfaceIpv6Config - 888, // 514: forge.FlatInterfaceConfig.vpc_routing_profile:type_name -> forge.RoutingProfile + 890, // 514: forge.FlatInterfaceConfig.vpc_routing_profile:type_name -> forge.RoutingProfile 410, // 515: forge.FlatInterfaceConfig.interface_routing_profile:type_name -> forge.FlatInterfaceRoutingProfile 412, // 516: forge.FlatInterfaceConfig.network_security_group:type_name -> forge.FlatInterfaceNetworkSecurityGroupConfig - 1028, // 517: forge.FlatInterfaceConfig.internal_uuid:type_name -> common.UUID - 887, // 518: forge.FlatInterfaceRoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry + 1030, // 517: forge.FlatInterfaceConfig.internal_uuid:type_name -> common.UUID + 889, // 518: forge.FlatInterfaceRoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry 58, // 519: forge.FlatInterfaceNetworkSecurityGroupConfig.source:type_name -> forge.NetworkSecurityGroupSource - 700, // 520: forge.FlatInterfaceNetworkSecurityGroupConfig.rules:type_name -> forge.ResolvedNetworkSecurityGroupRule + 702, // 520: forge.FlatInterfaceNetworkSecurityGroupConfig.rules:type_name -> forge.ResolvedNetworkSecurityGroupRule 461, // 521: forge.ManagedHostNetworkStatusResponse.all:type_name -> forge.DpuNetworkStatus - 1017, // 522: forge.DpuAgentUpgradeCheckRequest.binary_mtime:type_name -> google.protobuf.Timestamp + 1019, // 522: forge.DpuAgentUpgradeCheckRequest.binary_mtime:type_name -> google.protobuf.Timestamp 35, // 523: forge.DpuAgentUpgradePolicyRequest.new_policy:type_name -> forge.AgentUpgradePolicy 35, // 524: forge.DpuAgentUpgradePolicyResponse.active_policy:type_name -> forge.AgentUpgradePolicy 390, // 525: forge.LockdownRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 1016, // 526: forge.LockdownRequest.machine_id:type_name -> common.MachineId + 1018, // 526: forge.LockdownRequest.machine_id:type_name -> common.MachineId 36, // 527: forge.LockdownRequest.action:type_name -> forge.LockdownAction 390, // 528: forge.LockdownStatusRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 1016, // 529: forge.LockdownStatusRequest.machine_id:type_name -> common.MachineId + 1018, // 529: forge.LockdownStatusRequest.machine_id:type_name -> common.MachineId 390, // 530: forge.MachineSetupStatusRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest 390, // 531: forge.MachineSetupRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest 390, // 532: forge.SetDpuFirstBootOrderRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest @@ -70852,89 +70951,89 @@ var file_nico_nico_proto_depIdxs = []int32{ 390, // 534: forge.AdminBmcResetRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest 390, // 535: forge.EnableInfiniteBootRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest 390, // 536: forge.IsInfiniteBootEnabledRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 1016, // 537: forge.BMCMetaDataGetRequest.machine_id:type_name -> common.MachineId + 1018, // 537: forge.BMCMetaDataGetRequest.machine_id:type_name -> common.MachineId 31, // 538: forge.BMCMetaDataGetRequest.role:type_name -> forge.UserRoles 37, // 539: forge.BMCMetaDataGetRequest.request_type:type_name -> forge.BMCRequestType 390, // 540: forge.BMCMetaDataGetRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 1016, // 541: forge.MachineCredentialsUpdateRequest.machine_id:type_name -> common.MachineId - 985, // 542: forge.MachineCredentialsUpdateRequest.credentials:type_name -> forge.MachineCredentialsUpdateRequest.Credentials - 1016, // 543: forge.ForgeAgentControlRequest.machine_id:type_name -> common.MachineId + 1018, // 541: forge.MachineCredentialsUpdateRequest.machine_id:type_name -> common.MachineId + 987, // 542: forge.MachineCredentialsUpdateRequest.credentials:type_name -> forge.MachineCredentialsUpdateRequest.Credentials + 1018, // 543: forge.ForgeAgentControlRequest.machine_id:type_name -> common.MachineId 90, // 544: forge.ForgeAgentControlResponse.legacy_action:type_name -> forge.ForgeAgentControlResponse.LegacyAction - 986, // 545: forge.ForgeAgentControlResponse.data:type_name -> forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo - 987, // 546: forge.ForgeAgentControlResponse.noop:type_name -> forge.ForgeAgentControlResponse.Noop - 988, // 547: forge.ForgeAgentControlResponse.reset:type_name -> forge.ForgeAgentControlResponse.Reset - 989, // 548: forge.ForgeAgentControlResponse.discovery:type_name -> forge.ForgeAgentControlResponse.Discovery - 990, // 549: forge.ForgeAgentControlResponse.rebuild:type_name -> forge.ForgeAgentControlResponse.Rebuild - 991, // 550: forge.ForgeAgentControlResponse.retry:type_name -> forge.ForgeAgentControlResponse.Retry - 992, // 551: forge.ForgeAgentControlResponse.measure:type_name -> forge.ForgeAgentControlResponse.Measure - 993, // 552: forge.ForgeAgentControlResponse.log_error:type_name -> forge.ForgeAgentControlResponse.LogError - 994, // 553: forge.ForgeAgentControlResponse.machine_validation:type_name -> forge.ForgeAgentControlResponse.MachineValidation - 996, // 554: forge.ForgeAgentControlResponse.mlx_action:type_name -> forge.ForgeAgentControlResponse.MlxAction - 1003, // 555: forge.ForgeAgentControlResponse.firmware_upgrade:type_name -> forge.ForgeAgentControlResponse.FirmwareUpgrade - 1039, // 556: forge.MachineDiscoveryInfo.machine_interface_id:type_name -> common.MachineInterfaceId - 1040, // 557: forge.MachineDiscoveryInfo.info:type_name -> machine_discovery.DiscoveryInfo + 988, // 545: forge.ForgeAgentControlResponse.data:type_name -> forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo + 989, // 546: forge.ForgeAgentControlResponse.noop:type_name -> forge.ForgeAgentControlResponse.Noop + 990, // 547: forge.ForgeAgentControlResponse.reset:type_name -> forge.ForgeAgentControlResponse.Reset + 991, // 548: forge.ForgeAgentControlResponse.discovery:type_name -> forge.ForgeAgentControlResponse.Discovery + 992, // 549: forge.ForgeAgentControlResponse.rebuild:type_name -> forge.ForgeAgentControlResponse.Rebuild + 993, // 550: forge.ForgeAgentControlResponse.retry:type_name -> forge.ForgeAgentControlResponse.Retry + 994, // 551: forge.ForgeAgentControlResponse.measure:type_name -> forge.ForgeAgentControlResponse.Measure + 995, // 552: forge.ForgeAgentControlResponse.log_error:type_name -> forge.ForgeAgentControlResponse.LogError + 996, // 553: forge.ForgeAgentControlResponse.machine_validation:type_name -> forge.ForgeAgentControlResponse.MachineValidation + 998, // 554: forge.ForgeAgentControlResponse.mlx_action:type_name -> forge.ForgeAgentControlResponse.MlxAction + 1005, // 555: forge.ForgeAgentControlResponse.firmware_upgrade:type_name -> forge.ForgeAgentControlResponse.FirmwareUpgrade + 1041, // 556: forge.MachineDiscoveryInfo.machine_interface_id:type_name -> common.MachineInterfaceId + 1042, // 557: forge.MachineDiscoveryInfo.info:type_name -> machine_discovery.DiscoveryInfo 38, // 558: forge.MachineDiscoveryInfo.discovery_reporter:type_name -> forge.MachineDiscoveryReporter - 1016, // 559: forge.MachineDiscoveryCompletedRequest.machine_id:type_name -> common.MachineId - 1016, // 560: forge.MachineCleanupInfo.machine_id:type_name -> common.MachineId - 1005, // 561: forge.MachineCleanupInfo.nvme:type_name -> forge.MachineCleanupInfo.CleanupStepResult - 1005, // 562: forge.MachineCleanupInfo.ram:type_name -> forge.MachineCleanupInfo.CleanupStepResult - 1005, // 563: forge.MachineCleanupInfo.mem_overwrite:type_name -> forge.MachineCleanupInfo.CleanupStepResult - 1005, // 564: forge.MachineCleanupInfo.ib:type_name -> forge.MachineCleanupInfo.CleanupStepResult - 1005, // 565: forge.MachineCleanupInfo.hdd:type_name -> forge.MachineCleanupInfo.CleanupStepResult + 1018, // 559: forge.MachineDiscoveryCompletedRequest.machine_id:type_name -> common.MachineId + 1018, // 560: forge.MachineCleanupInfo.machine_id:type_name -> common.MachineId + 1007, // 561: forge.MachineCleanupInfo.nvme:type_name -> forge.MachineCleanupInfo.CleanupStepResult + 1007, // 562: forge.MachineCleanupInfo.ram:type_name -> forge.MachineCleanupInfo.CleanupStepResult + 1007, // 563: forge.MachineCleanupInfo.mem_overwrite:type_name -> forge.MachineCleanupInfo.CleanupStepResult + 1007, // 564: forge.MachineCleanupInfo.ib:type_name -> forge.MachineCleanupInfo.CleanupStepResult + 1007, // 565: forge.MachineCleanupInfo.hdd:type_name -> forge.MachineCleanupInfo.CleanupStepResult 91, // 566: forge.MachineCleanupInfo.result:type_name -> forge.MachineCleanupInfo.CleanupResult 447, // 567: forge.MachineCertificateResult.machine_certificate:type_name -> forge.MachineCertificate - 1016, // 568: forge.MachineDiscoveryResult.machine_id:type_name -> common.MachineId + 1018, // 568: forge.MachineDiscoveryResult.machine_id:type_name -> common.MachineId 447, // 569: forge.MachineDiscoveryResult.machine_certificate:type_name -> forge.MachineCertificate 137, // 570: forge.MachineDiscoveryResult.attest_key_challenge:type_name -> forge.AttestKeyBindChallenge - 1039, // 571: forge.MachineDiscoveryResult.machine_interface_id:type_name -> common.MachineInterfaceId - 1016, // 572: forge.ForgeScoutErrorReport.machine_id:type_name -> common.MachineId - 1039, // 573: forge.ForgeScoutErrorReport.machine_interface_id:type_name -> common.MachineInterfaceId + 1041, // 571: forge.MachineDiscoveryResult.machine_interface_id:type_name -> common.MachineInterfaceId + 1018, // 572: forge.ForgeScoutErrorReport.machine_id:type_name -> common.MachineId + 1041, // 573: forge.ForgeScoutErrorReport.machine_interface_id:type_name -> common.MachineInterfaceId 25, // 574: forge.PxeInstructionRequest.arch:type_name -> forge.MachineArchitecture - 1039, // 575: forge.PxeInstructionRequest.interface_id:type_name -> common.MachineInterfaceId + 1041, // 575: forge.PxeInstructionRequest.interface_id:type_name -> common.MachineInterfaceId 369, // 576: forge.CloudInitDiscoveryInstructions.machine_interface:type_name -> forge.MachineInterface - 894, // 577: forge.CloudInitDiscoveryInstructions.domain:type_name -> forge.PxeDomain + 896, // 577: forge.CloudInitDiscoveryInstructions.domain:type_name -> forge.PxeDomain 39, // 578: forge.CloudInitDiscoveryInstructions.bootstrap_ca_source:type_name -> forge.BootstrapCaSource 457, // 579: forge.CloudInitInstructions.discovery_instructions:type_name -> forge.CloudInitDiscoveryInstructions 458, // 580: forge.CloudInitInstructions.metadata:type_name -> forge.CloudInitMetaData - 1016, // 581: forge.DpuNetworkStatus.dpu_machine_id:type_name -> common.MachineId - 1017, // 582: forge.DpuNetworkStatus.observed_at:type_name -> google.protobuf.Timestamp + 1018, // 581: forge.DpuNetworkStatus.dpu_machine_id:type_name -> common.MachineId + 1019, // 582: forge.DpuNetworkStatus.observed_at:type_name -> google.protobuf.Timestamp 482, // 583: forge.DpuNetworkStatus.interfaces:type_name -> forge.InstanceInterfaceStatusObservation - 1034, // 584: forge.DpuNetworkStatus.instance_id:type_name -> common.InstanceId - 1025, // 585: forge.DpuNetworkStatus.dpu_health:type_name -> health.HealthReport + 1036, // 584: forge.DpuNetworkStatus.instance_id:type_name -> common.InstanceId + 1027, // 585: forge.DpuNetworkStatus.dpu_health:type_name -> health.HealthReport 483, // 586: forge.DpuNetworkStatus.fabric_interfaces:type_name -> forge.FabricInterfaceData 462, // 587: forge.DpuNetworkStatus.last_dhcp_requests:type_name -> forge.LastDhcpRequest 463, // 588: forge.DpuNetworkStatus.dpu_extension_services:type_name -> forge.DpuExtensionServiceStatusObservation - 779, // 589: forge.DpuNetworkStatus.astra_config_status:type_name -> forge.AstraConfigStatus - 1039, // 590: forge.LastDhcpRequest.host_interface_id:type_name -> common.MachineInterfaceId + 781, // 589: forge.DpuNetworkStatus.astra_config_status:type_name -> forge.AstraConfigStatus + 1041, // 590: forge.LastDhcpRequest.host_interface_id:type_name -> common.MachineInterfaceId 73, // 591: forge.DpuExtensionServiceStatusObservation.service_type:type_name -> forge.DpuExtensionServiceType 74, // 592: forge.DpuExtensionServiceStatusObservation.state:type_name -> forge.DpuExtensionServiceDeploymentStatus 464, // 593: forge.DpuExtensionServiceStatusObservation.components:type_name -> forge.DpuExtensionServiceComponent - 1025, // 594: forge.OptionalHealthReport.report:type_name -> health.HealthReport - 1025, // 595: forge.HealthReportEntry.report:type_name -> health.HealthReport + 1027, // 594: forge.OptionalHealthReport.report:type_name -> health.HealthReport + 1027, // 595: forge.HealthReportEntry.report:type_name -> health.HealthReport 41, // 596: forge.HealthReportEntry.mode:type_name -> forge.HealthReportApplyMode - 1016, // 597: forge.InsertMachineHealthReportRequest.machine_id:type_name -> common.MachineId + 1018, // 597: forge.InsertMachineHealthReportRequest.machine_id:type_name -> common.MachineId 466, // 598: forge.InsertMachineHealthReportRequest.health_report_entry:type_name -> forge.HealthReportEntry - 1027, // 599: forge.InsertRackHealthReportRequest.rack_id:type_name -> common.RackId + 1029, // 599: forge.InsertRackHealthReportRequest.rack_id:type_name -> common.RackId 466, // 600: forge.InsertRackHealthReportRequest.health_report_entry:type_name -> forge.HealthReportEntry - 1027, // 601: forge.RemoveRackHealthReportRequest.rack_id:type_name -> common.RackId - 1027, // 602: forge.ListRackHealthReportsRequest.rack_id:type_name -> common.RackId - 1029, // 603: forge.InsertSwitchHealthReportRequest.switch_id:type_name -> common.SwitchId + 1029, // 601: forge.RemoveRackHealthReportRequest.rack_id:type_name -> common.RackId + 1029, // 602: forge.ListRackHealthReportsRequest.rack_id:type_name -> common.RackId + 1031, // 603: forge.InsertSwitchHealthReportRequest.switch_id:type_name -> common.SwitchId 466, // 604: forge.InsertSwitchHealthReportRequest.health_report_entry:type_name -> forge.HealthReportEntry - 1029, // 605: forge.RemoveSwitchHealthReportRequest.switch_id:type_name -> common.SwitchId - 1029, // 606: forge.ListSwitchHealthReportsRequest.switch_id:type_name -> common.SwitchId - 1026, // 607: forge.InsertPowerShelfHealthReportRequest.power_shelf_id:type_name -> common.PowerShelfId + 1031, // 605: forge.RemoveSwitchHealthReportRequest.switch_id:type_name -> common.SwitchId + 1031, // 606: forge.ListSwitchHealthReportsRequest.switch_id:type_name -> common.SwitchId + 1028, // 607: forge.InsertPowerShelfHealthReportRequest.power_shelf_id:type_name -> common.PowerShelfId 466, // 608: forge.InsertPowerShelfHealthReportRequest.health_report_entry:type_name -> forge.HealthReportEntry - 1026, // 609: forge.RemovePowerShelfHealthReportRequest.power_shelf_id:type_name -> common.PowerShelfId - 1026, // 610: forge.ListPowerShelfHealthReportsRequest.power_shelf_id:type_name -> common.PowerShelfId + 1028, // 609: forge.RemovePowerShelfHealthReportRequest.power_shelf_id:type_name -> common.PowerShelfId + 1028, // 610: forge.ListPowerShelfHealthReportsRequest.power_shelf_id:type_name -> common.PowerShelfId 466, // 611: forge.ListHealthReportResponse.health_report_entries:type_name -> forge.HealthReportEntry - 1016, // 612: forge.RemoveMachineHealthReportRequest.machine_id:type_name -> common.MachineId - 1038, // 613: forge.ListNVLinkDomainHealthReportsRequest.domain_id:type_name -> common.NVLinkDomainId - 1038, // 614: forge.InsertNVLinkDomainHealthReportRequest.domain_id:type_name -> common.NVLinkDomainId + 1018, // 612: forge.RemoveMachineHealthReportRequest.machine_id:type_name -> common.MachineId + 1040, // 613: forge.ListNVLinkDomainHealthReportsRequest.domain_id:type_name -> common.NVLinkDomainId + 1040, // 614: forge.InsertNVLinkDomainHealthReportRequest.domain_id:type_name -> common.NVLinkDomainId 466, // 615: forge.InsertNVLinkDomainHealthReportRequest.health_report_entry:type_name -> forge.HealthReportEntry - 1038, // 616: forge.RemoveNVLinkDomainHealthReportRequest.domain_id:type_name -> common.NVLinkDomainId + 1040, // 616: forge.RemoveNVLinkDomainHealthReportRequest.domain_id:type_name -> common.NVLinkDomainId 40, // 617: forge.InstanceInterfaceStatusObservation.function_type:type_name -> forge.InterfaceFunctionType - 694, // 618: forge.InstanceInterfaceStatusObservation.network_security_group:type_name -> forge.NetworkSecurityGroupStatus - 1028, // 619: forge.InstanceInterfaceStatusObservation.internal_uuid:type_name -> common.UUID + 696, // 618: forge.InstanceInterfaceStatusObservation.network_security_group:type_name -> forge.NetworkSecurityGroupStatus + 1030, // 619: forge.InstanceInterfaceStatusObservation.internal_uuid:type_name -> common.UUID 484, // 620: forge.FabricInterfaceData.link_data:type_name -> forge.LinkData 273, // 621: forge.Tenant.metadata:type_name -> forge.Metadata 273, // 622: forge.CreateTenantRequest.metadata:type_name -> forge.Metadata @@ -70956,1534 +71055,1537 @@ var file_nico_nico_proto_depIdxs = []int32{ 492, // 638: forge.TenantKeysetsByIdsRequest.keyset_ids:type_name -> forge.TenantKeysetIdentifier 510, // 639: forge.ResourcePools.pools:type_name -> forge.ResourcePool 43, // 640: forge.MaintenanceRequest.operation:type_name -> forge.MaintenanceOperation - 1016, // 641: forge.MaintenanceRequest.host_id:type_name -> common.MachineId + 1018, // 641: forge.MaintenanceRequest.host_id:type_name -> common.MachineId 44, // 642: forge.SetDynamicConfigRequest.setting:type_name -> forge.ConfigSetting 540, // 643: forge.FindIpAddressResponse.matches:type_name -> forge.IpAddressMatch - 1028, // 644: forge.IdentifyUuidRequest.uuid:type_name -> common.UUID - 1028, // 645: forge.IdentifyUuidResponse.uuid:type_name -> common.UUID + 1030, // 644: forge.IdentifyUuidRequest.uuid:type_name -> common.UUID + 1030, // 645: forge.IdentifyUuidResponse.uuid:type_name -> common.UUID 45, // 646: forge.IdentifyUuidResponse.object_type:type_name -> forge.UuidType 46, // 647: forge.IdentifyMacResponse.object_type:type_name -> forge.MacOwner - 1016, // 648: forge.IdentifySerialResponse.machine_id:type_name -> common.MachineId - 1016, // 649: forge.DpuReprovisioningRequest.dpu_id:type_name -> common.MachineId + 1018, // 648: forge.IdentifySerialResponse.machine_id:type_name -> common.MachineId + 1018, // 649: forge.DpuReprovisioningRequest.dpu_id:type_name -> common.MachineId 92, // 650: forge.DpuReprovisioningRequest.mode:type_name -> forge.DpuReprovisioningRequest.Mode 47, // 651: forge.DpuReprovisioningRequest.initiator:type_name -> forge.UpdateInitiator - 1016, // 652: forge.DpuReprovisioningRequest.machine_id:type_name -> common.MachineId - 1006, // 653: forge.DpuReprovisioningListResponse.dpus:type_name -> forge.DpuReprovisioningListResponse.DpuReprovisioningListItem - 1016, // 654: forge.HostReprovisioningRequest.machine_id:type_name -> common.MachineId + 1018, // 652: forge.DpuReprovisioningRequest.machine_id:type_name -> common.MachineId + 1008, // 653: forge.DpuReprovisioningListResponse.dpus:type_name -> forge.DpuReprovisioningListResponse.DpuReprovisioningListItem + 1018, // 654: forge.HostReprovisioningRequest.machine_id:type_name -> common.MachineId 93, // 655: forge.HostReprovisioningRequest.mode:type_name -> forge.HostReprovisioningRequest.Mode 47, // 656: forge.HostReprovisioningRequest.initiator:type_name -> forge.UpdateInitiator 94, // 657: forge.BmcCredentialRotationRequest.mode:type_name -> forge.BmcCredentialRotationRequest.Mode - 1044, // 658: forge.BmcCredentialRotationRequest.device_id:type_name -> common.DeviceId + 1046, // 658: forge.BmcCredentialRotationRequest.device_id:type_name -> common.DeviceId 95, // 659: forge.UefiCredentialRotationRequest.mode:type_name -> forge.UefiCredentialRotationRequest.Mode - 1016, // 660: forge.UefiCredentialRotationRequest.machine_id:type_name -> common.MachineId - 1007, // 661: forge.HostReprovisioningListResponse.hosts:type_name -> forge.HostReprovisioningListResponse.HostReprovisioningListItem + 1018, // 660: forge.UefiCredentialRotationRequest.machine_id:type_name -> common.MachineId + 1009, // 661: forge.HostReprovisioningListResponse.hosts:type_name -> forge.HostReprovisioningListResponse.HostReprovisioningListItem 534, // 662: forge.DpuInfoStatusObservation.os_operational_state:type_name -> forge.DpuOsOperationalState 535, // 663: forge.DpuInfoStatusObservation.representors:type_name -> forge.DpuRepresentorStatus - 1017, // 664: forge.DpuInfoStatusObservation.last_heartbeat:type_name -> google.protobuf.Timestamp + 1019, // 664: forge.DpuInfoStatusObservation.last_heartbeat:type_name -> google.protobuf.Timestamp 536, // 665: forge.DpuInfo.observed_status:type_name -> forge.DpuInfoStatusObservation 537, // 666: forge.GetDpuInfoListResponse.dpu_list:type_name -> forge.DpuInfo 48, // 667: forge.IpAddressMatch.ip_type:type_name -> forge.IpType - 1039, // 668: forge.MachineBootOverride.machine_interface_id:type_name -> common.MachineInterfaceId - 1016, // 669: forge.ConnectedDevice.id:type_name -> common.MachineId + 1041, // 668: forge.MachineBootOverride.machine_interface_id:type_name -> common.MachineInterfaceId + 1018, // 669: forge.ConnectedDevice.id:type_name -> common.MachineId 542, // 670: forge.ConnectedDeviceList.connected_devices:type_name -> forge.ConnectedDevice 548, // 671: forge.MachineIdBmcIpPairs.pairs:type_name -> forge.MachineIdBmcIp - 1016, // 672: forge.MachineIdBmcIp.machine_id:type_name -> common.MachineId + 1018, // 672: forge.MachineIdBmcIp.machine_id:type_name -> common.MachineId 542, // 673: forge.NetworkDevice.devices:type_name -> forge.ConnectedDevice 549, // 674: forge.NetworkTopologyData.network_devices:type_name -> forge.NetworkDevice 49, // 675: forge.RouteServers.source_type:type_name -> forge.RouteServerSourceType 555, // 676: forge.RouteServerEntries.route_servers:type_name -> forge.RouteServer 49, // 677: forge.RouteServer.source_type:type_name -> forge.RouteServerSourceType - 1016, // 678: forge.SetHostUefiPasswordRequest.host_id:type_name -> common.MachineId - 1016, // 679: forge.ClearHostUefiPasswordRequest.host_id:type_name -> common.MachineId - 1028, // 680: forge.OsImageAttributes.id:type_name -> common.UUID - 560, // 681: forge.OsImage.attributes:type_name -> forge.OsImageAttributes - 50, // 682: forge.OsImage.status:type_name -> forge.OsImageStatus - 561, // 683: forge.ListOsImageResponse.images:type_name -> forge.OsImage - 1028, // 684: forge.DeleteOsImageRequest.id:type_name -> common.UUID - 1035, // 685: forge.GetIpxeTemplateRequest.id:type_name -> common.IpxeTemplateId - 282, // 686: forge.IpxeTemplateList.templates:type_name -> forge.IpxeTemplate - 12, // 687: forge.ExpectedHostNic.network_segment_type:type_name -> forge.NetworkSegmentType - 82, // 688: forge.ExpectedHostNic.role:type_name -> forge.ExpectedInterfaceRole - 83, // 689: forge.ExpectedHostNic.ip_allocation:type_name -> forge.ExpectedInterfaceIpAllocation - 273, // 690: forge.ExpectedMachine.metadata:type_name -> forge.Metadata - 1028, // 691: forge.ExpectedMachine.id:type_name -> common.UUID - 569, // 692: forge.ExpectedMachine.host_nics:type_name -> forge.ExpectedHostNic - 1027, // 693: forge.ExpectedMachine.rack_id:type_name -> common.RackId - 51, // 694: forge.ExpectedMachine.dpu_mode:type_name -> forge.DpuMode - 570, // 695: forge.ExpectedMachine.host_lifecycle_profile:type_name -> forge.HostLifecycleProfile - 52, // 696: forge.ExpectedMachine.bmc_ip_allocation:type_name -> forge.BmcIpAllocationType - 1028, // 697: forge.ExpectedMachineRequest.id:type_name -> common.UUID - 571, // 698: forge.ExpectedMachineList.expected_machines:type_name -> forge.ExpectedMachine - 575, // 699: forge.LinkedExpectedMachineList.expected_machines:type_name -> forge.LinkedExpectedMachine - 1016, // 700: forge.LinkedExpectedMachine.machine_id:type_name -> common.MachineId - 1028, // 701: forge.LinkedExpectedMachine.expected_machine_id:type_name -> common.UUID - 577, // 702: forge.UnexpectedMachineList.unexpected_machines:type_name -> forge.UnexpectedMachine - 1016, // 703: forge.UnexpectedMachine.machine_id:type_name -> common.MachineId - 573, // 704: forge.BatchExpectedMachineOperationRequest.expected_machines:type_name -> forge.ExpectedMachineList - 1028, // 705: forge.ExpectedMachineOperationResult.id:type_name -> common.UUID - 571, // 706: forge.ExpectedMachineOperationResult.expected_machine:type_name -> forge.ExpectedMachine - 579, // 707: forge.BatchExpectedMachineOperationResponse.results:type_name -> forge.ExpectedMachineOperationResult - 1016, // 708: forge.MachineRebootCompletedRequest.machine_id:type_name -> common.MachineId - 1016, // 709: forge.ScoutFirmwareUpgradeStatusRequest.machine_id:type_name -> common.MachineId - 1016, // 710: forge.MachineValidationCompletedRequest.machine_id:type_name -> common.MachineId - 1045, // 711: forge.MachineValidationCompletedRequest.validation_id:type_name -> common.MachineValidationId - 1017, // 712: forge.MachineValidationResult.start_time:type_name -> google.protobuf.Timestamp - 1017, // 713: forge.MachineValidationResult.end_time:type_name -> google.protobuf.Timestamp - 1045, // 714: forge.MachineValidationResult.validation_id:type_name -> common.MachineValidationId - 586, // 715: forge.MachineValidationResultPostRequest.result:type_name -> forge.MachineValidationResult - 586, // 716: forge.MachineValidationResultList.results:type_name -> forge.MachineValidationResult - 1016, // 717: forge.MachineValidationGetRequest.machine_id:type_name -> common.MachineId - 1045, // 718: forge.MachineValidationGetRequest.validation_id:type_name -> common.MachineValidationId - 53, // 719: forge.MachineValidationStatus.started:type_name -> forge.MachineValidationStarted - 54, // 720: forge.MachineValidationStatus.in_progress:type_name -> forge.MachineValidationInProgress - 55, // 721: forge.MachineValidationStatus.completed:type_name -> forge.MachineValidationCompleted - 1045, // 722: forge.MachineValidationRun.validation_id:type_name -> common.MachineValidationId - 1016, // 723: forge.MachineValidationRun.machine_id:type_name -> common.MachineId - 1017, // 724: forge.MachineValidationRun.start_time:type_name -> google.protobuf.Timestamp - 1017, // 725: forge.MachineValidationRun.end_time:type_name -> google.protobuf.Timestamp - 590, // 726: forge.MachineValidationRun.status:type_name -> forge.MachineValidationStatus - 1041, // 727: forge.MachineValidationRun.duration_to_complete:type_name -> google.protobuf.Duration - 1017, // 728: forge.MachineValidationRun.last_heartbeat_at:type_name -> google.protobuf.Timestamp - 1016, // 729: forge.MachineSetAutoUpdateRequest.machine_id:type_name -> common.MachineId - 96, // 730: forge.MachineSetAutoUpdateRequest.action:type_name -> forge.MachineSetAutoUpdateRequest.SetAutoupdateAction - 1017, // 731: forge.MachineValidationExternalConfig.timestamp:type_name -> google.protobuf.Timestamp - 595, // 732: forge.GetMachineValidationExternalConfigResponse.config:type_name -> forge.MachineValidationExternalConfig - 595, // 733: forge.GetMachineValidationExternalConfigsResponse.configs:type_name -> forge.MachineValidationExternalConfig - 1016, // 734: forge.MachineValidationOnDemandRequest.machine_id:type_name -> common.MachineId - 97, // 735: forge.MachineValidationOnDemandRequest.action:type_name -> forge.MachineValidationOnDemandRequest.Action - 1045, // 736: forge.MachineValidationOnDemandResponse.validation_id:type_name -> common.MachineValidationId - 603, // 737: forge.MaintenanceActivityConfig.firmware_upgrade:type_name -> forge.FirmwareUpgradeActivity - 605, // 738: forge.MaintenanceActivityConfig.configure_nmx_cluster:type_name -> forge.ConfigureNmxClusterActivity - 606, // 739: forge.MaintenanceActivityConfig.power_sequence:type_name -> forge.PowerSequenceActivity - 604, // 740: forge.MaintenanceActivityConfig.nvos_update:type_name -> forge.NvosUpdateActivity - 607, // 741: forge.RackMaintenanceScope.activities:type_name -> forge.MaintenanceActivityConfig - 1027, // 742: forge.RackMaintenanceOnDemandRequest.rack_id:type_name -> common.RackId - 608, // 743: forge.RackMaintenanceOnDemandRequest.scope:type_name -> forge.RackMaintenanceScope - 390, // 744: forge.AdminPowerControlRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 98, // 745: forge.AdminPowerControlRequest.action:type_name -> forge.AdminPowerControlRequest.SystemPowerControl - 1016, // 746: forge.GetRedfishJobStateRequest.machine_id:type_name -> common.MachineId - 99, // 747: forge.GetRedfishJobStateResponse.job_state:type_name -> forge.GetRedfishJobStateResponse.RedfishJobState - 591, // 748: forge.MachineValidationRunList.runs:type_name -> forge.MachineValidationRun - 1016, // 749: forge.MachineValidationRunListGetRequest.machine_id:type_name -> common.MachineId - 1045, // 750: forge.MachineValidationRunItemSearchFilter.validation_id:type_name -> common.MachineValidationId - 1028, // 751: forge.MachineValidationRunItemIdList.run_item_ids:type_name -> common.UUID - 1028, // 752: forge.MachineValidationRunItemsByIdsRequest.run_item_ids:type_name -> common.UUID - 621, // 753: forge.MachineValidationRunItemList.run_items:type_name -> forge.MachineValidationRunItem - 1028, // 754: forge.MachineValidationRunItem.run_item_id:type_name -> common.UUID - 1045, // 755: forge.MachineValidationRunItem.validation_id:type_name -> common.MachineValidationId - 1041, // 756: forge.MachineValidationRunItem.timeout:type_name -> google.protobuf.Duration - 1017, // 757: forge.MachineValidationRunItem.started_at:type_name -> google.protobuf.Timestamp - 1017, // 758: forge.MachineValidationRunItem.ended_at:type_name -> google.protobuf.Timestamp - 1017, // 759: forge.MachineValidationRunItem.last_heartbeat_at:type_name -> google.protobuf.Timestamp - 1028, // 760: forge.MachineValidationRunItem.current_attempt_id:type_name -> common.UUID - 1028, // 761: forge.MachineValidationAttemptGetRequest.attempt_id:type_name -> common.UUID - 1028, // 762: forge.MachineValidationAttempt.attempt_id:type_name -> common.UUID - 1028, // 763: forge.MachineValidationAttempt.run_item_id:type_name -> common.UUID - 1017, // 764: forge.MachineValidationAttempt.started_at:type_name -> google.protobuf.Timestamp - 1017, // 765: forge.MachineValidationAttempt.ended_at:type_name -> google.protobuf.Timestamp - 1017, // 766: forge.MachineValidationAttempt.last_heartbeat_at:type_name -> google.protobuf.Timestamp - 1045, // 767: forge.MachineValidationHeartbeatRequest.validation_id:type_name -> common.MachineValidationId - 1028, // 768: forge.MachineValidationHeartbeatRequest.run_item_id:type_name -> common.UUID - 1028, // 769: forge.MachineValidationHeartbeatRequest.attempt_id:type_name -> common.UUID - 1008, // 770: forge.MachineValidationTestUpdateRequest.payload:type_name -> forge.MachineValidationTestUpdateRequest.Payload - 635, // 771: forge.MachineValidationTestsGetResponse.tests:type_name -> forge.MachineValidationTest - 1045, // 772: forge.MachineValidationRunRequest.validation_id:type_name -> common.MachineValidationId - 1041, // 773: forge.MachineValidationRunRequest.duration_to_complete:type_name -> google.protobuf.Duration - 635, // 774: forge.MachineValidationRunRequest.selected_tests:type_name -> forge.MachineValidationTest - 56, // 775: forge.MachineCapabilityAttributesGpu.device_type:type_name -> forge.MachineCapabilityDeviceType - 56, // 776: forge.MachineCapabilityAttributesNetwork.device_type:type_name -> forge.MachineCapabilityDeviceType - 642, // 777: forge.MachineCapabilitiesSet.cpu:type_name -> forge.MachineCapabilityAttributesCpu - 643, // 778: forge.MachineCapabilitiesSet.gpu:type_name -> forge.MachineCapabilityAttributesGpu - 644, // 779: forge.MachineCapabilitiesSet.memory:type_name -> forge.MachineCapabilityAttributesMemory - 645, // 780: forge.MachineCapabilitiesSet.storage:type_name -> forge.MachineCapabilityAttributesStorage - 646, // 781: forge.MachineCapabilitiesSet.network:type_name -> forge.MachineCapabilityAttributesNetwork - 647, // 782: forge.MachineCapabilitiesSet.infiniband:type_name -> forge.MachineCapabilityAttributesInfiniband - 648, // 783: forge.MachineCapabilitiesSet.dpu:type_name -> forge.MachineCapabilityAttributesDpu - 652, // 784: forge.InstanceTypeAttributes.desired_capabilities:type_name -> forge.InstanceTypeMachineCapabilityFilterAttributes - 650, // 785: forge.InstanceType.attributes:type_name -> forge.InstanceTypeAttributes - 273, // 786: forge.InstanceType.metadata:type_name -> forge.Metadata - 750, // 787: forge.InstanceType.allocation_stats:type_name -> forge.InstanceTypeAllocationStats - 57, // 788: forge.InstanceTypeMachineCapabilityFilterAttributes.capability_type:type_name -> forge.MachineCapabilityType - 1046, // 789: forge.InstanceTypeMachineCapabilityFilterAttributes.inactive_devices:type_name -> common.Uint32List - 56, // 790: forge.InstanceTypeMachineCapabilityFilterAttributes.device_type:type_name -> forge.MachineCapabilityDeviceType - 273, // 791: forge.CreateInstanceTypeRequest.metadata:type_name -> forge.Metadata - 650, // 792: forge.CreateInstanceTypeRequest.instance_type_attributes:type_name -> forge.InstanceTypeAttributes - 651, // 793: forge.CreateInstanceTypeResponse.instance_type:type_name -> forge.InstanceType - 651, // 794: forge.FindInstanceTypesByIdsResponse.instance_types:type_name -> forge.InstanceType - 651, // 795: forge.UpdateInstanceTypeResponse.instance_type:type_name -> forge.InstanceType - 273, // 796: forge.UpdateInstanceTypeRequest.metadata:type_name -> forge.Metadata - 650, // 797: forge.UpdateInstanceTypeRequest.instance_type_attributes:type_name -> forge.InstanceTypeAttributes - 1009, // 798: forge.RedfishBrowseResponse.headers:type_name -> forge.RedfishBrowseResponse.HeadersEntry - 671, // 799: forge.RedfishListActionsResponse.actions:type_name -> forge.RedfishAction - 1017, // 800: forge.RedfishAction.approver_dates:type_name -> google.protobuf.Timestamp - 1017, // 801: forge.RedfishAction.applied_at:type_name -> google.protobuf.Timestamp - 672, // 802: forge.RedfishAction.results:type_name -> forge.OptionalRedfishActionResult - 673, // 803: forge.OptionalRedfishActionResult.result:type_name -> forge.RedfishActionResult - 1010, // 804: forge.RedfishActionResult.headers:type_name -> forge.RedfishActionResult.HeadersEntry - 1017, // 805: forge.RedfishActionResult.completed_at:type_name -> google.protobuf.Timestamp - 1011, // 806: forge.UfmBrowseResponse.headers:type_name -> forge.UfmBrowseResponse.HeadersEntry - 699, // 807: forge.NetworkSecurityGroupAttributes.rules:type_name -> forge.NetworkSecurityGroupRuleAttributes - 273, // 808: forge.NetworkSecurityGroup.metadata:type_name -> forge.Metadata - 682, // 809: forge.NetworkSecurityGroup.attributes:type_name -> forge.NetworkSecurityGroupAttributes - 273, // 810: forge.CreateNetworkSecurityGroupRequest.metadata:type_name -> forge.Metadata - 682, // 811: forge.CreateNetworkSecurityGroupRequest.network_security_group_attributes:type_name -> forge.NetworkSecurityGroupAttributes - 683, // 812: forge.CreateNetworkSecurityGroupResponse.network_security_group:type_name -> forge.NetworkSecurityGroup - 683, // 813: forge.FindNetworkSecurityGroupsByIdsResponse.network_security_groups:type_name -> forge.NetworkSecurityGroup - 683, // 814: forge.UpdateNetworkSecurityGroupResponse.network_security_group:type_name -> forge.NetworkSecurityGroup - 273, // 815: forge.UpdateNetworkSecurityGroupRequest.metadata:type_name -> forge.Metadata - 682, // 816: forge.UpdateNetworkSecurityGroupRequest.network_security_group_attributes:type_name -> forge.NetworkSecurityGroupAttributes - 58, // 817: forge.NetworkSecurityGroupStatus.source:type_name -> forge.NetworkSecurityGroupSource - 59, // 818: forge.NetworkSecurityGroupPropagationObjectStatus.status:type_name -> forge.NetworkSecurityGroupPropagationStatus - 695, // 819: forge.GetNetworkSecurityGroupPropagationStatusResponse.vpcs:type_name -> forge.NetworkSecurityGroupPropagationObjectStatus - 695, // 820: forge.GetNetworkSecurityGroupPropagationStatusResponse.instances:type_name -> forge.NetworkSecurityGroupPropagationObjectStatus - 697, // 821: forge.GetNetworkSecurityGroupPropagationStatusRequest.network_security_group_ids:type_name -> forge.NetworkSecurityGroupIdList - 60, // 822: forge.NetworkSecurityGroupRuleAttributes.direction:type_name -> forge.NetworkSecurityGroupRuleDirection - 61, // 823: forge.NetworkSecurityGroupRuleAttributes.protocol:type_name -> forge.NetworkSecurityGroupRuleProtocol - 62, // 824: forge.NetworkSecurityGroupRuleAttributes.action:type_name -> forge.NetworkSecurityGroupRuleAction - 699, // 825: forge.ResolvedNetworkSecurityGroupRule.rule:type_name -> forge.NetworkSecurityGroupRuleAttributes - 702, // 826: forge.GetNetworkSecurityGroupAttachmentsResponse.attachments:type_name -> forge.NetworkSecurityGroupAttachments - 706, // 827: forge.GetDesiredFirmwareVersionsResponse.entries:type_name -> forge.DesiredFirmwareVersionEntry - 1012, // 828: forge.DesiredFirmwareVersionEntry.component_versions:type_name -> forge.DesiredFirmwareVersionEntry.ComponentVersionsEntry - 707, // 829: forge.SkuComponents.chassis:type_name -> forge.SkuComponentChassis - 708, // 830: forge.SkuComponents.cpus:type_name -> forge.SkuComponentCpu - 709, // 831: forge.SkuComponents.gpus:type_name -> forge.SkuComponentGpu - 710, // 832: forge.SkuComponents.ethernet_devices:type_name -> forge.SkuComponentEthernetDevices - 711, // 833: forge.SkuComponents.infiniband_devices:type_name -> forge.SkuComponentInfinibandDevices - 712, // 834: forge.SkuComponents.storage:type_name -> forge.SkuComponentStorage - 714, // 835: forge.SkuComponents.memory:type_name -> forge.SkuComponentMemory - 715, // 836: forge.SkuComponents.tpm:type_name -> forge.SkuComponentTpm - 1017, // 837: forge.Sku.created:type_name -> google.protobuf.Timestamp - 716, // 838: forge.Sku.components:type_name -> forge.SkuComponents - 1016, // 839: forge.Sku.associated_machine_ids:type_name -> common.MachineId - 1016, // 840: forge.SkuMachinePair.machine_id:type_name -> common.MachineId - 1016, // 841: forge.RemoveSkuRequest.machine_id:type_name -> common.MachineId - 717, // 842: forge.SkuList.skus:type_name -> forge.Sku - 1017, // 843: forge.SkuStatus.verify_request_time:type_name -> google.protobuf.Timestamp - 1017, // 844: forge.SkuStatus.last_match_attempt:type_name -> google.protobuf.Timestamp - 1017, // 845: forge.SkuStatus.last_generate_attempt:type_name -> google.protobuf.Timestamp - 1047, // 846: forge.DpaInterface.id:type_name -> common.DpaInterfaceId - 1016, // 847: forge.DpaInterface.machine_id:type_name -> common.MachineId - 1017, // 848: forge.DpaInterface.created:type_name -> google.protobuf.Timestamp - 1017, // 849: forge.DpaInterface.updated:type_name -> google.protobuf.Timestamp - 1017, // 850: forge.DpaInterface.deleted:type_name -> google.protobuf.Timestamp - 237, // 851: forge.DpaInterface.history:type_name -> forge.StateHistoryRecord - 1017, // 852: forge.DpaInterface.last_hb_time:type_name -> google.protobuf.Timestamp - 63, // 853: forge.DpaInterface.interface_type:type_name -> forge.DpaInterfaceType - 1016, // 854: forge.DpaInterfaceCreationRequest.machine_id:type_name -> common.MachineId - 63, // 855: forge.DpaInterfaceCreationRequest.interface_type:type_name -> forge.DpaInterfaceType - 1047, // 856: forge.DpaInterfaceIdList.ids:type_name -> common.DpaInterfaceId - 1047, // 857: forge.DpaInterfacesByIdsRequest.ids:type_name -> common.DpaInterfaceId - 725, // 858: forge.DpaInterfaceList.interfaces:type_name -> forge.DpaInterface - 1047, // 859: forge.DpaNetworkObservationSetRequest.id:type_name -> common.DpaInterfaceId - 1047, // 860: forge.DpaInterfaceDeletionRequest.id:type_name -> common.DpaInterfaceId - 1016, // 861: forge.PowerOptionRequest.machine_id:type_name -> common.MachineId - 1016, // 862: forge.PowerOptionUpdateRequest.machine_id:type_name -> common.MachineId - 64, // 863: forge.PowerOptionUpdateRequest.power_state:type_name -> forge.PowerState - 64, // 864: forge.PowerOptions.desired_state:type_name -> forge.PowerState - 1017, // 865: forge.PowerOptions.desired_state_updated_at:type_name -> google.protobuf.Timestamp - 64, // 866: forge.PowerOptions.actual_state:type_name -> forge.PowerState - 1017, // 867: forge.PowerOptions.actual_state_updated_at:type_name -> google.protobuf.Timestamp - 1016, // 868: forge.PowerOptions.host_id:type_name -> common.MachineId - 1017, // 869: forge.PowerOptions.next_power_state_fetch_at:type_name -> google.protobuf.Timestamp - 1017, // 870: forge.PowerOptions.tried_triggering_on_at:type_name -> google.protobuf.Timestamp - 1017, // 871: forge.PowerOptions.wait_until_time_before_performing_next_power_action:type_name -> google.protobuf.Timestamp - 736, // 872: forge.PowerOptionResponse.response:type_name -> forge.PowerOptions - 1048, // 873: forge.ComputeAllocation.id:type_name -> common.ComputeAllocationId - 738, // 874: forge.ComputeAllocation.attributes:type_name -> forge.ComputeAllocationAttributes - 273, // 875: forge.ComputeAllocation.metadata:type_name -> forge.Metadata - 1048, // 876: forge.CreateComputeAllocationRequest.id:type_name -> common.ComputeAllocationId - 273, // 877: forge.CreateComputeAllocationRequest.metadata:type_name -> forge.Metadata - 738, // 878: forge.CreateComputeAllocationRequest.attributes:type_name -> forge.ComputeAllocationAttributes - 739, // 879: forge.CreateComputeAllocationResponse.allocation:type_name -> forge.ComputeAllocation - 1048, // 880: forge.FindComputeAllocationIdsResponse.ids:type_name -> common.ComputeAllocationId - 1048, // 881: forge.FindComputeAllocationsByIdsRequest.ids:type_name -> common.ComputeAllocationId - 739, // 882: forge.FindComputeAllocationsByIdsResponse.allocations:type_name -> forge.ComputeAllocation - 739, // 883: forge.UpdateComputeAllocationResponse.allocation:type_name -> forge.ComputeAllocation - 1048, // 884: forge.UpdateComputeAllocationRequest.id:type_name -> common.ComputeAllocationId - 273, // 885: forge.UpdateComputeAllocationRequest.metadata:type_name -> forge.Metadata - 738, // 886: forge.UpdateComputeAllocationRequest.attributes:type_name -> forge.ComputeAllocationAttributes - 1048, // 887: forge.DeleteComputeAllocationRequest.id:type_name -> common.ComputeAllocationId - 757, // 888: forge.GetRackResponse.rack:type_name -> forge.Rack - 757, // 889: forge.RackList.racks:type_name -> forge.Rack - 272, // 890: forge.RackSearchFilter.label:type_name -> forge.Label - 1027, // 891: forge.RackIdList.rack_ids:type_name -> common.RackId - 1027, // 892: forge.RacksByIdsRequest.rack_ids:type_name -> common.RackId - 1027, // 893: forge.Rack.id:type_name -> common.RackId - 1017, // 894: forge.Rack.created:type_name -> google.protobuf.Timestamp - 1017, // 895: forge.Rack.updated:type_name -> google.protobuf.Timestamp - 1017, // 896: forge.Rack.deleted:type_name -> google.protobuf.Timestamp - 273, // 897: forge.Rack.metadata:type_name -> forge.Metadata - 758, // 898: forge.Rack.config:type_name -> forge.RackConfig - 759, // 899: forge.Rack.status:type_name -> forge.RackStatus - 1025, // 900: forge.RackStatus.health:type_name -> health.HealthReport - 363, // 901: forge.RackStatus.health_sources:type_name -> forge.HealthSourceOrigin - 101, // 902: forge.RackStatus.lifecycle:type_name -> forge.LifecycleStatus - 1027, // 903: forge.RackStateHistoriesRequest.rack_ids:type_name -> common.RackId - 1027, // 904: forge.AdminForceDeleteRackRequest.rack_id:type_name -> common.RackId - 764, // 905: forge.RackCapabilitiesSet.compute:type_name -> forge.RackCapabilityCompute - 765, // 906: forge.RackCapabilitiesSet.switch:type_name -> forge.RackCapabilitySwitch - 766, // 907: forge.RackCapabilitiesSet.power_shelf:type_name -> forge.RackCapabilityPowerShelf - 1049, // 908: forge.RackProfile.rack_hardware_type:type_name -> common.RackHardwareType - 65, // 909: forge.RackProfile.rack_hardware_topology:type_name -> forge.RackHardwareTopology - 67, // 910: forge.RackProfile.rack_hardware_class:type_name -> forge.RackHardwareClass - 767, // 911: forge.RackProfile.capabilities:type_name -> forge.RackCapabilitiesSet - 66, // 912: forge.RackProfile.product_family:type_name -> forge.RackProductFamily - 1027, // 913: forge.GetRackProfileRequest.rack_id:type_name -> common.RackId - 1027, // 914: forge.GetRackProfileResponse.rack_id:type_name -> common.RackId - 1030, // 915: forge.GetRackProfileResponse.rack_profile_id:type_name -> common.RackProfileId - 768, // 916: forge.GetRackProfileResponse.profile:type_name -> forge.RackProfile - 68, // 917: forge.RackManagerForgeRequest.cmd:type_name -> forge.RackManagerForgeCmd - 1038, // 918: forge.MachineNVLinkInfo.domain_uuid:type_name -> common.NVLinkDomainId - 782, // 919: forge.MachineNVLinkInfo.gpus:type_name -> forge.NVLinkGpu - 1016, // 920: forge.UpdateMachineNvLinkInfoRequest.machine_id:type_name -> common.MachineId - 773, // 921: forge.UpdateMachineNvLinkInfoRequest.nvlink_info:type_name -> forge.MachineNVLinkInfo - 776, // 922: forge.MachineSpxStatusObservation.attachment_status:type_name -> forge.MachineSpxAttachmentStatusObservation - 1017, // 923: forge.MachineSpxStatusObservation.observed_at:type_name -> google.protobuf.Timestamp - 1037, // 924: forge.MachineSpxAttachmentStatusObservation.partition_id:type_name -> common.SpxPartitionId - 16, // 925: forge.MachineSpxAttachmentStatusObservation.attachment_type:type_name -> forge.SpxAttachmentType - 1017, // 926: forge.MachineSpxAttachmentStatusObservation.observed_at:type_name -> google.protobuf.Timestamp - 778, // 927: forge.AstraConfig.astra_attachments:type_name -> forge.AstraAttachment - 16, // 928: forge.AstraAttachment.attachment_type:type_name -> forge.SpxAttachmentType - 780, // 929: forge.AstraConfigStatus.astra_attachments_status:type_name -> forge.AstraAttachmentStatus - 16, // 930: forge.AstraAttachmentStatus.attachment_type:type_name -> forge.SpxAttachmentType - 781, // 931: forge.AstraAttachmentStatus.status:type_name -> forge.AstraStatus - 69, // 932: forge.AstraStatus.phase:type_name -> forge.AstraPhase - 784, // 933: forge.MachineNVLinkStatusObservation.gpu_status:type_name -> forge.MachineNVLinkGpuStatusObservation - 1050, // 934: forge.MachineNVLinkGpuStatusObservation.partition_id:type_name -> common.NVLinkPartitionId - 1021, // 935: forge.MachineNVLinkGpuStatusObservation.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId - 1038, // 936: forge.MachineNVLinkGpuStatusObservation.domain_id:type_name -> common.NVLinkDomainId - 70, // 937: forge.NmxcBrowseRequest.operation:type_name -> forge.NmxcBrowseOperation - 1013, // 938: forge.NmxcBrowseResponse.headers:type_name -> forge.NmxcBrowseResponse.HeadersEntry - 1050, // 939: forge.NVLinkPartition.id:type_name -> common.NVLinkPartitionId - 1038, // 940: forge.NVLinkPartition.domain_uuid:type_name -> common.NVLinkDomainId - 1021, // 941: forge.NVLinkPartition.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId - 787, // 942: forge.NVLinkPartitionList.partitions:type_name -> forge.NVLinkPartition - 1028, // 943: forge.NVLinkPartitionQuery.id:type_name -> common.UUID - 789, // 944: forge.NVLinkPartitionQuery.search_config:type_name -> forge.NVLinkPartitionSearchConfig - 1050, // 945: forge.NVLinkPartitionsByIdsRequest.partition_ids:type_name -> common.NVLinkPartitionId - 1050, // 946: forge.NVLinkPartitionIdList.partition_ids:type_name -> common.NVLinkPartitionId - 273, // 947: forge.NVLinkLogicalPartitionConfig.metadata:type_name -> forge.Metadata - 8, // 948: forge.NVLinkLogicalPartitionStatus.state:type_name -> forge.TenantState - 1021, // 949: forge.NVLinkLogicalPartition.id:type_name -> common.NVLinkLogicalPartitionId - 795, // 950: forge.NVLinkLogicalPartition.config:type_name -> forge.NVLinkLogicalPartitionConfig - 796, // 951: forge.NVLinkLogicalPartition.status:type_name -> forge.NVLinkLogicalPartitionStatus - 1017, // 952: forge.NVLinkLogicalPartition.created:type_name -> google.protobuf.Timestamp - 797, // 953: forge.NVLinkLogicalPartitionList.partitions:type_name -> forge.NVLinkLogicalPartition - 795, // 954: forge.NVLinkLogicalPartitionCreationRequest.config:type_name -> forge.NVLinkLogicalPartitionConfig - 1021, // 955: forge.NVLinkLogicalPartitionCreationRequest.id:type_name -> common.NVLinkLogicalPartitionId - 1021, // 956: forge.NVLinkLogicalPartitionDeletionRequest.id:type_name -> common.NVLinkLogicalPartitionId - 1021, // 957: forge.NVLinkLogicalPartitionsByIdsRequest.partition_ids:type_name -> common.NVLinkLogicalPartitionId - 1021, // 958: forge.NVLinkLogicalPartitionIdList.partition_ids:type_name -> common.NVLinkLogicalPartitionId - 1021, // 959: forge.NVLinkLogicalPartitionUpdateRequest.id:type_name -> common.NVLinkLogicalPartitionId - 795, // 960: forge.NVLinkLogicalPartitionUpdateRequest.config:type_name -> forge.NVLinkLogicalPartitionConfig - 390, // 961: forge.CreateBmcUserRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 390, // 962: forge.DeleteBmcUserRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 390, // 963: forge.SetBmcRootPasswordRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 390, // 964: forge.ProbeBmcVendorRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest - 1016, // 965: forge.SetFirmwareUpdateTimeWindowRequest.machine_ids:type_name -> common.MachineId - 1017, // 966: forge.SetFirmwareUpdateTimeWindowRequest.start_timestamp:type_name -> google.protobuf.Timestamp - 1017, // 967: forge.SetFirmwareUpdateTimeWindowRequest.end_timestamp:type_name -> google.protobuf.Timestamp - 819, // 968: forge.UpsertHostFirmwareConfigRequest.components:type_name -> forge.UpsertHostFirmwareComponentConfig - 71, // 969: forge.UpsertHostFirmwareConfigRequest.ordering:type_name -> forge.HostFirmwareComponentType - 71, // 970: forge.UpsertHostFirmwareComponentConfig.type:type_name -> forge.HostFirmwareComponentType - 821, // 971: forge.UpsertHostFirmwareComponentConfig.firmware:type_name -> forge.HostFirmwareVersionConfig - 71, // 972: forge.HostFirmwareComponentConfigResponse.type:type_name -> forge.HostFirmwareComponentType - 821, // 973: forge.HostFirmwareComponentConfigResponse.firmware:type_name -> forge.HostFirmwareVersionConfig - 822, // 974: forge.HostFirmwareVersionConfig.artifacts:type_name -> forge.HostFirmwareArtifact - 820, // 975: forge.HostFirmwareConfigResponse.components:type_name -> forge.HostFirmwareComponentConfigResponse - 71, // 976: forge.HostFirmwareConfigResponse.ordering:type_name -> forge.HostFirmwareComponentType - 1017, // 977: forge.HostFirmwareConfigResponse.created_at:type_name -> google.protobuf.Timestamp - 1017, // 978: forge.HostFirmwareConfigResponse.updated_at:type_name -> google.protobuf.Timestamp - 826, // 979: forge.ListHostFirmwareResponse.available:type_name -> forge.AvailableHostFirmware - 72, // 980: forge.TrimTableRequest.target:type_name -> forge.TrimTableTarget - 829, // 981: forge.NvlinkNmxcEndpointList.entries:type_name -> forge.NvlinkNmxcEndpoint - 273, // 982: forge.CreateRemediationRequest.metadata:type_name -> forge.Metadata - 1051, // 983: forge.CreateRemediationResponse.remediation_id:type_name -> common.RemediationId - 1051, // 984: forge.RemediationIdList.remediation_ids:type_name -> common.RemediationId - 836, // 985: forge.RemediationList.remediations:type_name -> forge.Remediation - 1051, // 986: forge.Remediation.id:type_name -> common.RemediationId - 273, // 987: forge.Remediation.metadata:type_name -> forge.Metadata - 1017, // 988: forge.Remediation.creation_time:type_name -> google.protobuf.Timestamp - 1051, // 989: forge.ApproveRemediationRequest.remediation_id:type_name -> common.RemediationId - 1051, // 990: forge.RevokeRemediationRequest.remediation_id:type_name -> common.RemediationId - 1051, // 991: forge.EnableRemediationRequest.remediation_id:type_name -> common.RemediationId - 1051, // 992: forge.DisableRemediationRequest.remediation_id:type_name -> common.RemediationId - 1051, // 993: forge.FindAppliedRemediationIdsRequest.remediation_id:type_name -> common.RemediationId - 1016, // 994: forge.FindAppliedRemediationIdsRequest.dpu_machine_id:type_name -> common.MachineId - 1051, // 995: forge.AppliedRemediationIdList.remediation_ids:type_name -> common.RemediationId - 1016, // 996: forge.AppliedRemediationIdList.dpu_machine_ids:type_name -> common.MachineId - 1051, // 997: forge.FindAppliedRemediationsRequest.remediation_id:type_name -> common.RemediationId - 1016, // 998: forge.FindAppliedRemediationsRequest.dpu_machine_id:type_name -> common.MachineId - 1051, // 999: forge.AppliedRemediation.remediation_id:type_name -> common.RemediationId - 1016, // 1000: forge.AppliedRemediation.dpu_machine_id:type_name -> common.MachineId - 1017, // 1001: forge.AppliedRemediation.applied_time:type_name -> google.protobuf.Timestamp - 273, // 1002: forge.AppliedRemediation.metadata:type_name -> forge.Metadata - 844, // 1003: forge.AppliedRemediationList.applied_remediations:type_name -> forge.AppliedRemediation - 1016, // 1004: forge.GetNextRemediationForMachineRequest.dpu_machine_id:type_name -> common.MachineId - 1051, // 1005: forge.GetNextRemediationForMachineResponse.remediation_id:type_name -> common.RemediationId - 1051, // 1006: forge.RemediationAppliedRequest.remediation_id:type_name -> common.RemediationId - 1016, // 1007: forge.RemediationAppliedRequest.dpu_machine_id:type_name -> common.MachineId - 849, // 1008: forge.RemediationAppliedRequest.status:type_name -> forge.RemediationApplicationStatus - 273, // 1009: forge.RemediationApplicationStatus.metadata:type_name -> forge.Metadata - 1016, // 1010: forge.SetPrimaryDpuRequest.host_machine_id:type_name -> common.MachineId - 1016, // 1011: forge.SetPrimaryDpuRequest.dpu_machine_id:type_name -> common.MachineId - 1016, // 1012: forge.SetPrimaryInterfaceRequest.host_machine_id:type_name -> common.MachineId - 1039, // 1013: forge.SetPrimaryInterfaceRequest.interface_id:type_name -> common.MachineInterfaceId - 852, // 1014: forge.DpuExtensionServiceCredential.username_password:type_name -> forge.UsernamePassword - 873, // 1015: forge.DpuExtensionServiceVersionInfo.observability:type_name -> forge.DpuExtensionServiceObservability - 73, // 1016: forge.DpuExtensionService.service_type:type_name -> forge.DpuExtensionServiceType - 855, // 1017: forge.DpuExtensionService.latest_version_info:type_name -> forge.DpuExtensionServiceVersionInfo - 73, // 1018: forge.CreateDpuExtensionServiceRequest.service_type:type_name -> forge.DpuExtensionServiceType - 854, // 1019: forge.CreateDpuExtensionServiceRequest.credential:type_name -> forge.DpuExtensionServiceCredential - 873, // 1020: forge.CreateDpuExtensionServiceRequest.observability:type_name -> forge.DpuExtensionServiceObservability - 854, // 1021: forge.UpdateDpuExtensionServiceRequest.credential:type_name -> forge.DpuExtensionServiceCredential - 873, // 1022: forge.UpdateDpuExtensionServiceRequest.observability:type_name -> forge.DpuExtensionServiceObservability - 73, // 1023: forge.DpuExtensionServiceSearchFilter.service_type:type_name -> forge.DpuExtensionServiceType - 856, // 1024: forge.DpuExtensionServiceList.services:type_name -> forge.DpuExtensionService - 855, // 1025: forge.DpuExtensionServiceVersionInfoList.version_infos:type_name -> forge.DpuExtensionServiceVersionInfo - 869, // 1026: forge.FindInstancesByDpuExtensionServiceResponse.instances:type_name -> forge.InstanceDpuExtensionServiceInfo - 870, // 1027: forge.DpuExtensionServiceObservabilityConfig.prometheus:type_name -> forge.DpuExtensionServiceObservabilityConfigPrometheus - 871, // 1028: forge.DpuExtensionServiceObservabilityConfig.logging:type_name -> forge.DpuExtensionServiceObservabilityConfigLogging - 872, // 1029: forge.DpuExtensionServiceObservability.configs:type_name -> forge.DpuExtensionServiceObservabilityConfig - 1028, // 1030: forge.ScoutStreamApiBoundMessage.flow_uuid:type_name -> common.UUID - 876, // 1031: forge.ScoutStreamApiBoundMessage.init:type_name -> forge.ScoutStreamInitRequest - 1052, // 1032: forge.ScoutStreamApiBoundMessage.mlx_device_lockdown_response:type_name -> mlx_device.MlxDeviceLockdownResponse - 1053, // 1033: forge.ScoutStreamApiBoundMessage.mlx_device_profile_sync_response:type_name -> mlx_device.MlxDeviceProfileSyncResponse - 1054, // 1034: forge.ScoutStreamApiBoundMessage.mlx_device_profile_compare_response:type_name -> mlx_device.MlxDeviceProfileCompareResponse - 1055, // 1035: forge.ScoutStreamApiBoundMessage.mlx_device_info_device_response:type_name -> mlx_device.MlxDeviceInfoDeviceResponse - 1056, // 1036: forge.ScoutStreamApiBoundMessage.mlx_device_info_report_response:type_name -> mlx_device.MlxDeviceInfoReportResponse - 1057, // 1037: forge.ScoutStreamApiBoundMessage.mlx_device_registry_list_response:type_name -> mlx_device.MlxDeviceRegistryListResponse - 1058, // 1038: forge.ScoutStreamApiBoundMessage.mlx_device_registry_show_response:type_name -> mlx_device.MlxDeviceRegistryShowResponse - 1059, // 1039: forge.ScoutStreamApiBoundMessage.mlx_device_config_query_response:type_name -> mlx_device.MlxDeviceConfigQueryResponse - 1060, // 1040: forge.ScoutStreamApiBoundMessage.mlx_device_config_set_response:type_name -> mlx_device.MlxDeviceConfigSetResponse - 1061, // 1041: forge.ScoutStreamApiBoundMessage.mlx_device_config_sync_response:type_name -> mlx_device.MlxDeviceConfigSyncResponse - 1062, // 1042: forge.ScoutStreamApiBoundMessage.mlx_device_config_compare_response:type_name -> mlx_device.MlxDeviceConfigCompareResponse - 884, // 1043: forge.ScoutStreamApiBoundMessage.scout_stream_agent_ping_response:type_name -> forge.ScoutStreamAgentPingResponse - 1028, // 1044: forge.ScoutStreamScoutBoundMessage.flow_uuid:type_name -> common.UUID - 1063, // 1045: forge.ScoutStreamScoutBoundMessage.mlx_device_lockdown_lock_request:type_name -> mlx_device.MlxDeviceLockdownLockRequest - 1064, // 1046: forge.ScoutStreamScoutBoundMessage.mlx_device_lockdown_unlock_request:type_name -> mlx_device.MlxDeviceLockdownUnlockRequest - 1065, // 1047: forge.ScoutStreamScoutBoundMessage.mlx_device_lockdown_status_request:type_name -> mlx_device.MlxDeviceLockdownStatusRequest - 1066, // 1048: forge.ScoutStreamScoutBoundMessage.mlx_device_profile_sync_request:type_name -> mlx_device.MlxDeviceProfileSyncRequest - 1067, // 1049: forge.ScoutStreamScoutBoundMessage.mlx_device_profile_compare_request:type_name -> mlx_device.MlxDeviceProfileCompareRequest - 1068, // 1050: forge.ScoutStreamScoutBoundMessage.mlx_device_info_device_request:type_name -> mlx_device.MlxDeviceInfoDeviceRequest - 1069, // 1051: forge.ScoutStreamScoutBoundMessage.mlx_device_info_report_request:type_name -> mlx_device.MlxDeviceInfoReportRequest - 1070, // 1052: forge.ScoutStreamScoutBoundMessage.mlx_device_registry_list_request:type_name -> mlx_device.MlxDeviceRegistryListRequest - 1071, // 1053: forge.ScoutStreamScoutBoundMessage.mlx_device_registry_show_request:type_name -> mlx_device.MlxDeviceRegistryShowRequest - 1072, // 1054: forge.ScoutStreamScoutBoundMessage.mlx_device_config_query_request:type_name -> mlx_device.MlxDeviceConfigQueryRequest - 1073, // 1055: forge.ScoutStreamScoutBoundMessage.mlx_device_config_set_request:type_name -> mlx_device.MlxDeviceConfigSetRequest - 1074, // 1056: forge.ScoutStreamScoutBoundMessage.mlx_device_config_sync_request:type_name -> mlx_device.MlxDeviceConfigSyncRequest - 1075, // 1057: forge.ScoutStreamScoutBoundMessage.mlx_device_config_compare_request:type_name -> mlx_device.MlxDeviceConfigCompareRequest - 883, // 1058: forge.ScoutStreamScoutBoundMessage.scout_stream_agent_ping_request:type_name -> forge.ScoutStreamAgentPingRequest - 1016, // 1059: forge.ScoutStreamInitRequest.machine_id:type_name -> common.MachineId - 885, // 1060: forge.ScoutStreamShowConnectionsResponse.scout_stream_connections:type_name -> forge.ScoutStreamConnectionInfo - 1016, // 1061: forge.ScoutStreamDisconnectRequest.machine_id:type_name -> common.MachineId - 1016, // 1062: forge.ScoutStreamDisconnectResponse.machine_id:type_name -> common.MachineId - 1016, // 1063: forge.ScoutStreamAdminPingRequest.machine_id:type_name -> common.MachineId - 886, // 1064: forge.ScoutStreamAgentPingResponse.error:type_name -> forge.ScoutStreamError - 1016, // 1065: forge.ScoutStreamConnectionInfo.machine_id:type_name -> common.MachineId - 75, // 1066: forge.ScoutStreamError.status:type_name -> forge.ScoutStreamErrorStatus - 1020, // 1067: forge.RoutingProfile.route_target_imports:type_name -> common.RouteTarget - 1020, // 1068: forge.RoutingProfile.route_targets_on_exports:type_name -> common.RouteTarget - 887, // 1069: forge.RoutingProfile.accepted_leaks_from_underlay:type_name -> forge.PrefixFilterPolicyEntry - 887, // 1070: forge.RoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry - 1031, // 1071: forge.DomainLegacy.id:type_name -> common.DomainId - 1017, // 1072: forge.DomainLegacy.created:type_name -> google.protobuf.Timestamp - 1017, // 1073: forge.DomainLegacy.updated:type_name -> google.protobuf.Timestamp - 1017, // 1074: forge.DomainLegacy.deleted:type_name -> google.protobuf.Timestamp - 889, // 1075: forge.DomainListLegacy.domains:type_name -> forge.DomainLegacy - 1031, // 1076: forge.DomainDeletionLegacy.id:type_name -> common.DomainId - 1031, // 1077: forge.DomainSearchQueryLegacy.id:type_name -> common.DomainId - 1076, // 1078: forge.PxeDomain.new_domain:type_name -> dns.Domain - 889, // 1079: forge.PxeDomain.legacy_domain:type_name -> forge.DomainLegacy - 1016, // 1080: forge.MachinePositionQuery.machine_ids:type_name -> common.MachineId - 897, // 1081: forge.MachinePositionInfoList.machine_position_info:type_name -> forge.MachinePositionInfo - 1016, // 1082: forge.MachinePositionInfo.machine_id:type_name -> common.MachineId - 1029, // 1083: forge.MachinePositionInfo.switch_id:type_name -> common.SwitchId - 1026, // 1084: forge.MachinePositionInfo.power_shelf_id:type_name -> common.PowerShelfId - 1016, // 1085: forge.ModifyDPFStateRequest.machine_id:type_name -> common.MachineId - 1014, // 1086: forge.DPFStateResponse.dpf_states:type_name -> forge.DPFStateResponse.DPFState - 1016, // 1087: forge.GetDPFStateRequest.machine_ids:type_name -> common.MachineId - 1016, // 1088: forge.GetDPFHostSnapshotRequest.host_machine_id:type_name -> common.MachineId - 904, // 1089: forge.DPFServiceVersionsResponse.services:type_name -> forge.DPFServiceVersion - 76, // 1090: forge.ComponentResult.status:type_name -> forge.ComponentManagerStatusCode - 1029, // 1091: forge.SwitchIdList.ids:type_name -> common.SwitchId - 1026, // 1092: forge.PowerShelfIdList.ids:type_name -> common.PowerShelfId - 1077, // 1093: forge.GetComponentInventoryRequest.machine_ids:type_name -> common.MachineIdList - 907, // 1094: forge.GetComponentInventoryRequest.switch_ids:type_name -> forge.SwitchIdList - 908, // 1095: forge.GetComponentInventoryRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList - 906, // 1096: forge.ComponentInventoryEntry.result:type_name -> forge.ComponentResult - 1078, // 1097: forge.ComponentInventoryEntry.report:type_name -> site_explorer.EndpointExplorationReport - 910, // 1098: forge.GetComponentInventoryResponse.entries:type_name -> forge.ComponentInventoryEntry - 1077, // 1099: forge.ComponentPowerControlRequest.machine_ids:type_name -> common.MachineIdList - 907, // 1100: forge.ComponentPowerControlRequest.switch_ids:type_name -> forge.SwitchIdList - 908, // 1101: forge.ComponentPowerControlRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList - 1079, // 1102: forge.ComponentPowerControlRequest.action:type_name -> common.SystemPowerControl - 906, // 1103: forge.ComponentPowerControlResponse.results:type_name -> forge.ComponentResult - 907, // 1104: forge.ComponentConfigureSwitchCertificateRequest.switch_ids:type_name -> forge.SwitchIdList - 906, // 1105: forge.ComponentConfigureSwitchCertificateResponse.results:type_name -> forge.ComponentResult - 906, // 1106: forge.FirmwareUpdateStatus.result:type_name -> forge.ComponentResult - 77, // 1107: forge.FirmwareUpdateStatus.state:type_name -> forge.FirmwareUpdateState - 1017, // 1108: forge.FirmwareUpdateStatus.updated_at:type_name -> google.protobuf.Timestamp - 1077, // 1109: forge.UpdateComputeTrayFirmwareTarget.machine_ids:type_name -> common.MachineIdList - 80, // 1110: forge.UpdateComputeTrayFirmwareTarget.components:type_name -> forge.ComputeTrayComponent - 907, // 1111: forge.UpdateSwitchFirmwareTarget.switch_ids:type_name -> forge.SwitchIdList - 78, // 1112: forge.UpdateSwitchFirmwareTarget.components:type_name -> forge.NvSwitchComponent - 908, // 1113: forge.UpdatePowerShelfFirmwareTarget.power_shelf_ids:type_name -> forge.PowerShelfIdList - 79, // 1114: forge.UpdatePowerShelfFirmwareTarget.components:type_name -> forge.PowerShelfComponent - 755, // 1115: forge.UpdateFirmwareObjectTarget.rack_ids:type_name -> forge.RackIdList - 917, // 1116: forge.UpdateComponentFirmwareRequest.compute_trays:type_name -> forge.UpdateComputeTrayFirmwareTarget - 918, // 1117: forge.UpdateComponentFirmwareRequest.switches:type_name -> forge.UpdateSwitchFirmwareTarget - 919, // 1118: forge.UpdateComponentFirmwareRequest.power_shelves:type_name -> forge.UpdatePowerShelfFirmwareTarget - 920, // 1119: forge.UpdateComponentFirmwareRequest.racks:type_name -> forge.UpdateFirmwareObjectTarget - 906, // 1120: forge.UpdateComponentFirmwareResponse.results:type_name -> forge.ComponentResult - 1077, // 1121: forge.GetComponentFirmwareStatusRequest.machine_ids:type_name -> common.MachineIdList - 907, // 1122: forge.GetComponentFirmwareStatusRequest.switch_ids:type_name -> forge.SwitchIdList - 908, // 1123: forge.GetComponentFirmwareStatusRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList - 755, // 1124: forge.GetComponentFirmwareStatusRequest.rack_ids:type_name -> forge.RackIdList - 916, // 1125: forge.GetComponentFirmwareStatusResponse.statuses:type_name -> forge.FirmwareUpdateStatus - 1077, // 1126: forge.ListComponentFirmwareVersionsRequest.machine_ids:type_name -> common.MachineIdList - 907, // 1127: forge.ListComponentFirmwareVersionsRequest.switch_ids:type_name -> forge.SwitchIdList - 908, // 1128: forge.ListComponentFirmwareVersionsRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList - 755, // 1129: forge.ListComponentFirmwareVersionsRequest.rack_ids:type_name -> forge.RackIdList - 80, // 1130: forge.ComputeTrayFirmwareVersions.component:type_name -> forge.ComputeTrayComponent - 906, // 1131: forge.DeviceFirmwareVersions.result:type_name -> forge.ComponentResult - 926, // 1132: forge.DeviceFirmwareVersions.compute_fw_versions:type_name -> forge.ComputeTrayFirmwareVersions - 927, // 1133: forge.ListComponentFirmwareVersionsResponse.devices:type_name -> forge.DeviceFirmwareVersions - 273, // 1134: forge.SpxPartitionCreationRequest.metadata:type_name -> forge.Metadata - 1037, // 1135: forge.SpxPartitionCreationRequest.id:type_name -> common.SpxPartitionId - 273, // 1136: forge.SpxPartition.metadata:type_name -> forge.Metadata - 1037, // 1137: forge.SpxPartition.id:type_name -> common.SpxPartitionId - 1037, // 1138: forge.SpxPartitionIdList.spx_partition_ids:type_name -> common.SpxPartitionId - 1037, // 1139: forge.SpxPartitionDeletionRequest.id:type_name -> common.SpxPartitionId - 272, // 1140: forge.SpxPartitionSearchFilter.label:type_name -> forge.Label - 930, // 1141: forge.SpxPartitionList.spx_partitions:type_name -> forge.SpxPartition - 1037, // 1142: forge.SpxPartitionsByIdsRequest.spx_partition_ids:type_name -> common.SpxPartitionId - 1029, // 1143: forge.AdminForceDeleteSwitchRequest.switch_id:type_name -> common.SwitchId - 1026, // 1144: forge.AdminForceDeletePowerShelfRequest.power_shelf_id:type_name -> common.PowerShelfId - 1036, // 1145: forge.OperatingSystem.id:type_name -> common.OperatingSystemId - 81, // 1146: forge.OperatingSystem.type:type_name -> forge.OperatingSystemType - 8, // 1147: forge.OperatingSystem.status:type_name -> forge.TenantState - 1035, // 1148: forge.OperatingSystem.ipxe_template_id:type_name -> common.IpxeTemplateId - 280, // 1149: forge.OperatingSystem.ipxe_template_parameters:type_name -> forge.IpxeTemplateParameter - 281, // 1150: forge.OperatingSystem.ipxe_template_artifacts:type_name -> forge.IpxeTemplateArtifact - 1036, // 1151: forge.CreateOperatingSystemRequest.id:type_name -> common.OperatingSystemId - 1035, // 1152: forge.CreateOperatingSystemRequest.ipxe_template_id:type_name -> common.IpxeTemplateId - 280, // 1153: forge.CreateOperatingSystemRequest.ipxe_template_parameters:type_name -> forge.IpxeTemplateParameter - 281, // 1154: forge.CreateOperatingSystemRequest.ipxe_template_artifacts:type_name -> forge.IpxeTemplateArtifact - 280, // 1155: forge.IpxeTemplateParameters.items:type_name -> forge.IpxeTemplateParameter - 281, // 1156: forge.IpxeTemplateArtifacts.items:type_name -> forge.IpxeTemplateArtifact - 1036, // 1157: forge.UpdateOperatingSystemRequest.id:type_name -> common.OperatingSystemId - 1035, // 1158: forge.UpdateOperatingSystemRequest.ipxe_template_id:type_name -> common.IpxeTemplateId - 943, // 1159: forge.UpdateOperatingSystemRequest.ipxe_template_parameters:type_name -> forge.IpxeTemplateParameters - 944, // 1160: forge.UpdateOperatingSystemRequest.ipxe_template_artifacts:type_name -> forge.IpxeTemplateArtifacts - 1036, // 1161: forge.DeleteOperatingSystemRequest.id:type_name -> common.OperatingSystemId - 1036, // 1162: forge.OperatingSystemIdList.ids:type_name -> common.OperatingSystemId - 1036, // 1163: forge.OperatingSystemsByIdsRequest.ids:type_name -> common.OperatingSystemId - 941, // 1164: forge.OperatingSystemList.operating_systems:type_name -> forge.OperatingSystem - 1036, // 1165: forge.GetOperatingSystemCachableIpxeTemplateArtifactsRequest.id:type_name -> common.OperatingSystemId - 281, // 1166: forge.IpxeTemplateArtifactList.artifacts:type_name -> forge.IpxeTemplateArtifact - 1036, // 1167: forge.UpdateOperatingSystemIpxeTemplateArtifactRequest.id:type_name -> common.OperatingSystemId - 954, // 1168: forge.UpdateOperatingSystemIpxeTemplateArtifactRequest.updates:type_name -> forge.IpxeTemplateArtifactUpdateRequest - 1016, // 1169: forge.GetMachineBootInterfacesRequest.machine_id:type_name -> common.MachineId - 1039, // 1170: forge.MachineInterfaceBootInterface.interface_id:type_name -> common.MachineInterfaceId - 1017, // 1171: forge.RetainedBootInterface.recorded_at:type_name -> google.protobuf.Timestamp - 1016, // 1172: forge.GetMachineBootInterfacesResponse.machine_id:type_name -> common.MachineId - 961, // 1173: forge.GetMachineBootInterfacesResponse.machine_interfaces:type_name -> forge.MachineInterfaceBootInterface - 962, // 1174: forge.GetMachineBootInterfacesResponse.predicted_interfaces:type_name -> forge.PredictedBootInterface - 963, // 1175: forge.GetMachineBootInterfacesResponse.explored_endpoints:type_name -> forge.ExploredBootInterface - 964, // 1176: forge.GetMachineBootInterfacesResponse.retained_interfaces:type_name -> forge.RetainedBootInterface - 960, // 1177: forge.GetMachineBootInterfacesResponse.default_boot_interface:type_name -> forge.MachineBootInterface - 960, // 1178: forge.GetMachineBootInterfacesResponse.predicted_boot_interface:type_name -> forge.MachineBootInterface - 1015, // 1179: forge.GetMachineBootInterfacesResponse.reconciliation:type_name -> forge.GetMachineBootInterfacesResponse.Reconciliation - 1080, // 1180: forge.SitePrefix.id:type_name -> common.SitePrefixId - 970, // 1181: forge.SitePrefix.config:type_name -> forge.SitePrefixConfig - 971, // 1182: forge.SitePrefix.status:type_name -> forge.SitePrefixStatus - 273, // 1183: forge.SitePrefix.metadata:type_name -> forge.Metadata - 1017, // 1184: forge.SitePrefix.created_at:type_name -> google.protobuf.Timestamp - 1017, // 1185: forge.SitePrefix.updated_at:type_name -> google.protobuf.Timestamp - 85, // 1186: forge.SitePrefixConfig.routing_scope:type_name -> forge.SitePrefixRoutingScope - 84, // 1187: forge.SitePrefixStatus.authority:type_name -> forge.SitePrefixAuthority - 86, // 1188: forge.SitePrefixStatus.lifecycle_state:type_name -> forge.SitePrefixLifecycleState - 84, // 1189: forge.SitePrefixSearchFilter.authority:type_name -> forge.SitePrefixAuthority - 85, // 1190: forge.SitePrefixSearchFilter.routing_scope:type_name -> forge.SitePrefixRoutingScope - 86, // 1191: forge.SitePrefixSearchFilter.lifecycle_state:type_name -> forge.SitePrefixLifecycleState - 7, // 1192: forge.SitePrefixSearchFilter.prefix_match_type:type_name -> forge.PrefixMatchType - 1080, // 1193: forge.SitePrefixesByIdsRequest.site_prefix_ids:type_name -> common.SitePrefixId - 1080, // 1194: forge.SitePrefixIdList.site_prefix_ids:type_name -> common.SitePrefixId - 969, // 1195: forge.SitePrefixList.site_prefixes:type_name -> forge.SitePrefix - 979, // 1196: forge.DNSMessage.DNSResponse.rrs:type_name -> forge.DNSMessage.DNSResponse.DNSRR - 238, // 1197: forge.StateHistories.HistoriesEntry.value:type_name -> forge.StateHistoryRecords - 329, // 1198: forge.MachineStateHistories.HistoriesEntry.value:type_name -> forge.MachineStateHistoryRecords - 332, // 1199: forge.HealthHistories.HistoriesEntry.value:type_name -> forge.HealthHistoryRecords - 956, // 1200: forge.TrafficInterceptBridging.HostRepresentorInterceptBridgingEntry.value:type_name -> forge.HostRepresentorInterceptBridging - 89, // 1201: forge.MachineCredentialsUpdateRequest.Credentials.credential_purpose:type_name -> forge.MachineCredentialsUpdateRequest.CredentialPurpose - 1004, // 1202: forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo.pair:type_name -> forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo.KeyValuePair - 1045, // 1203: forge.ForgeAgentControlResponse.MachineValidation.validation_id:type_name -> common.MachineValidationId - 995, // 1204: forge.ForgeAgentControlResponse.MachineValidation.filter:type_name -> forge.ForgeAgentControlResponse.MachineValidationFilter - 1042, // 1205: forge.ForgeAgentControlResponse.MachineValidationFilter.contexts:type_name -> common.StringList - 997, // 1206: forge.ForgeAgentControlResponse.MlxAction.device_actions:type_name -> forge.ForgeAgentControlResponse.MlxDeviceAction - 998, // 1207: forge.ForgeAgentControlResponse.MlxDeviceAction.noop:type_name -> forge.ForgeAgentControlResponse.MlxDeviceNoop - 999, // 1208: forge.ForgeAgentControlResponse.MlxDeviceAction.lock:type_name -> forge.ForgeAgentControlResponse.MlxDeviceLock - 1000, // 1209: forge.ForgeAgentControlResponse.MlxDeviceAction.unlock:type_name -> forge.ForgeAgentControlResponse.MlxDeviceUnlock - 1001, // 1210: forge.ForgeAgentControlResponse.MlxDeviceAction.apply_profile:type_name -> forge.ForgeAgentControlResponse.MlxDeviceApplyProfile - 1002, // 1211: forge.ForgeAgentControlResponse.MlxDeviceAction.apply_firmware:type_name -> forge.ForgeAgentControlResponse.MlxDeviceApplyFirmware - 1081, // 1212: forge.ForgeAgentControlResponse.MlxDeviceApplyProfile.serialized_profile:type_name -> mlx_device.SerializableMlxConfigProfile - 1082, // 1213: forge.ForgeAgentControlResponse.MlxDeviceApplyFirmware.profile:type_name -> mlx_device.FirmwareFlasherProfile - 1083, // 1214: forge.ForgeAgentControlResponse.FirmwareUpgrade.task:type_name -> scout_firmware_upgrade.ScoutFirmwareUpgradeTask - 91, // 1215: forge.MachineCleanupInfo.CleanupStepResult.result:type_name -> forge.MachineCleanupInfo.CleanupResult - 1016, // 1216: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem.id:type_name -> common.MachineId - 1017, // 1217: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem.requested_at:type_name -> google.protobuf.Timestamp - 1017, // 1218: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem.initiated_at:type_name -> google.protobuf.Timestamp - 1016, // 1219: forge.HostReprovisioningListResponse.HostReprovisioningListItem.id:type_name -> common.MachineId - 1017, // 1220: forge.HostReprovisioningListResponse.HostReprovisioningListItem.requested_at:type_name -> google.protobuf.Timestamp - 1017, // 1221: forge.HostReprovisioningListResponse.HostReprovisioningListItem.initiated_at:type_name -> google.protobuf.Timestamp - 1016, // 1222: forge.DPFStateResponse.DPFState.machine_id:type_name -> common.MachineId - 960, // 1223: forge.GetMachineBootInterfacesResponse.Reconciliation.desired_boot_interface:type_name -> forge.MachineBootInterface - 1017, // 1224: forge.GetMachineBootInterfacesResponse.Reconciliation.observed_at:type_name -> google.protobuf.Timestamp - 100, // 1225: forge.GetMachineBootInterfacesResponse.Reconciliation.reconciliation_state:type_name -> forge.GetMachineBootInterfacesResponse.Reconciliation.State - 149, // 1226: forge.Forge.Version:input_type -> forge.VersionRequest - 1084, // 1227: forge.Forge.CreateDomain:input_type -> dns.CreateDomainRequest - 1085, // 1228: forge.Forge.UpdateDomain:input_type -> dns.UpdateDomainRequest - 1086, // 1229: forge.Forge.DeleteDomain:input_type -> dns.DomainDeletionRequest - 1087, // 1230: forge.Forge.FindDomain:input_type -> dns.DomainSearchQuery - 889, // 1231: forge.Forge.CreateDomainLegacy:input_type -> forge.DomainLegacy - 889, // 1232: forge.Forge.UpdateDomainLegacy:input_type -> forge.DomainLegacy - 891, // 1233: forge.Forge.DeleteDomainLegacy:input_type -> forge.DomainDeletionLegacy - 893, // 1234: forge.Forge.FindDomainLegacy:input_type -> forge.DomainSearchQueryLegacy - 171, // 1235: forge.Forge.CreateVpc:input_type -> forge.VpcCreationRequest - 172, // 1236: forge.Forge.UpdateVpc:input_type -> forge.VpcUpdateRequest - 174, // 1237: forge.Forge.UpdateVpcVirtualization:input_type -> forge.VpcUpdateVirtualizationRequest - 176, // 1238: forge.Forge.DeleteVpc:input_type -> forge.VpcDeletionRequest - 161, // 1239: forge.Forge.FindVpcIds:input_type -> forge.VpcSearchFilter - 163, // 1240: forge.Forge.FindVpcsByIds:input_type -> forge.VpcsByIdsRequest - 929, // 1241: forge.Forge.CreateSpxPartition:input_type -> forge.SpxPartitionCreationRequest - 932, // 1242: forge.Forge.DeleteSpxPartition:input_type -> forge.SpxPartitionDeletionRequest - 934, // 1243: forge.Forge.FindSpxPartitionIds:input_type -> forge.SpxPartitionSearchFilter - 936, // 1244: forge.Forge.FindSpxPartitionsByIds:input_type -> forge.SpxPartitionsByIdsRequest - 182, // 1245: forge.Forge.CreateVpcPrefix:input_type -> forge.VpcPrefixCreationRequest - 183, // 1246: forge.Forge.SearchVpcPrefixes:input_type -> forge.VpcPrefixSearchQuery - 184, // 1247: forge.Forge.GetVpcPrefixes:input_type -> forge.VpcPrefixGetRequest - 187, // 1248: forge.Forge.UpdateVpcPrefix:input_type -> forge.VpcPrefixUpdateRequest - 188, // 1249: forge.Forge.DeleteVpcPrefix:input_type -> forge.VpcPrefixDeletionRequest - 972, // 1250: forge.Forge.FindSitePrefixIds:input_type -> forge.SitePrefixSearchFilter - 973, // 1251: forge.Forge.FindSitePrefixesByIds:input_type -> forge.SitePrefixesByIdsRequest - 194, // 1252: forge.Forge.CreateVpcPeering:input_type -> forge.VpcPeeringCreationRequest - 195, // 1253: forge.Forge.FindVpcPeeringIds:input_type -> forge.VpcPeeringSearchFilter - 196, // 1254: forge.Forge.FindVpcPeeringsByIds:input_type -> forge.VpcPeeringsByIdsRequest - 197, // 1255: forge.Forge.DeleteVpcPeering:input_type -> forge.VpcPeeringDeletionRequest - 264, // 1256: forge.Forge.FindNetworkSegmentIds:input_type -> forge.NetworkSegmentSearchFilter - 266, // 1257: forge.Forge.FindNetworkSegmentsByIds:input_type -> forge.NetworkSegmentsByIdsRequest - 258, // 1258: forge.Forge.CreateNetworkSegment:input_type -> forge.NetworkSegmentCreationRequest - 260, // 1259: forge.Forge.AttachNetworkSegmentToVpc:input_type -> forge.AttachNetworkSegmentToVpcRequest - 259, // 1260: forge.Forge.DeleteNetworkSegment:input_type -> forge.NetworkSegmentDeletionRequest - 160, // 1261: forge.Forge.NetworkSegmentsForVpc:input_type -> forge.VpcSearchQuery - 207, // 1262: forge.Forge.FindIBPartitionIds:input_type -> forge.IBPartitionSearchFilter - 208, // 1263: forge.Forge.FindIBPartitionsByIds:input_type -> forge.IBPartitionsByIdsRequest - 203, // 1264: forge.Forge.CreateIBPartition:input_type -> forge.IBPartitionCreationRequest - 204, // 1265: forge.Forge.UpdateIBPartition:input_type -> forge.IBPartitionUpdateRequest - 205, // 1266: forge.Forge.DeleteIBPartition:input_type -> forge.IBPartitionDeletionRequest - 164, // 1267: forge.Forge.IBPartitionsForTenant:input_type -> forge.TenantSearchQuery - 219, // 1268: forge.Forge.FindPowerShelves:input_type -> forge.PowerShelfQuery - 220, // 1269: forge.Forge.FindPowerShelfIds:input_type -> forge.PowerShelfSearchFilter - 221, // 1270: forge.Forge.FindPowerShelvesByIds:input_type -> forge.PowerShelvesByIdsRequest - 215, // 1271: forge.Forge.DeletePowerShelf:input_type -> forge.PowerShelfDeletionRequest - 939, // 1272: forge.Forge.AdminForceDeletePowerShelf:input_type -> forge.AdminForceDeletePowerShelfRequest - 217, // 1273: forge.Forge.SetPowerShelfMaintenance:input_type -> forge.PowerShelfMaintenanceRequest - 241, // 1274: forge.Forge.FindSwitches:input_type -> forge.SwitchQuery - 242, // 1275: forge.Forge.FindSwitchIds:input_type -> forge.SwitchSearchFilter - 243, // 1276: forge.Forge.FindSwitchesByIds:input_type -> forge.SwitchesByIdsRequest - 235, // 1277: forge.Forge.DeleteSwitch:input_type -> forge.SwitchDeletionRequest - 937, // 1278: forge.Forge.AdminForceDeleteSwitch:input_type -> forge.AdminForceDeleteSwitchRequest - 252, // 1279: forge.Forge.FindIBFabricIds:input_type -> forge.IBFabricSearchFilter - 277, // 1280: forge.Forge.AllocateInstance:input_type -> forge.InstanceAllocationRequest - 278, // 1281: forge.Forge.AllocateInstances:input_type -> forge.BatchInstanceAllocationRequest - 323, // 1282: forge.Forge.ReleaseInstance:input_type -> forge.InstanceReleaseRequest - 295, // 1283: forge.Forge.UpdateInstanceOperatingSystem:input_type -> forge.InstanceOperatingSystemUpdateRequest - 296, // 1284: forge.Forge.UpdateInstanceConfig:input_type -> forge.InstanceConfigUpdateRequest - 274, // 1285: forge.Forge.FindInstanceIds:input_type -> forge.InstanceSearchFilter - 276, // 1286: forge.Forge.FindInstancesByIds:input_type -> forge.InstancesByIdsRequest - 1016, // 1287: forge.Forge.FindInstanceByMachineID:input_type -> common.MachineId - 396, // 1288: forge.Forge.GetManagedHostNetworkConfig:input_type -> forge.ManagedHostNetworkConfigRequest - 461, // 1289: forge.Forge.RecordDpuNetworkStatus:input_type -> forge.DpuNetworkStatus - 1016, // 1290: forge.Forge.ListMachineHealthReports:input_type -> common.MachineId - 467, // 1291: forge.Forge.InsertMachineHealthReport:input_type -> forge.InsertMachineHealthReportRequest - 478, // 1292: forge.Forge.RemoveMachineHealthReport:input_type -> forge.RemoveMachineHealthReportRequest - 470, // 1293: forge.Forge.ListRackHealthReports:input_type -> forge.ListRackHealthReportsRequest - 468, // 1294: forge.Forge.InsertRackHealthReport:input_type -> forge.InsertRackHealthReportRequest - 469, // 1295: forge.Forge.RemoveRackHealthReport:input_type -> forge.RemoveRackHealthReportRequest - 473, // 1296: forge.Forge.ListSwitchHealthReports:input_type -> forge.ListSwitchHealthReportsRequest - 471, // 1297: forge.Forge.InsertSwitchHealthReport:input_type -> forge.InsertSwitchHealthReportRequest - 472, // 1298: forge.Forge.RemoveSwitchHealthReport:input_type -> forge.RemoveSwitchHealthReportRequest - 476, // 1299: forge.Forge.ListPowerShelfHealthReports:input_type -> forge.ListPowerShelfHealthReportsRequest - 474, // 1300: forge.Forge.InsertPowerShelfHealthReport:input_type -> forge.InsertPowerShelfHealthReportRequest - 475, // 1301: forge.Forge.RemovePowerShelfHealthReport:input_type -> forge.RemovePowerShelfHealthReportRequest - 479, // 1302: forge.Forge.ListNVLinkDomainHealthReports:input_type -> forge.ListNVLinkDomainHealthReportsRequest - 480, // 1303: forge.Forge.InsertNVLinkDomainHealthReport:input_type -> forge.InsertNVLinkDomainHealthReportRequest - 481, // 1304: forge.Forge.RemoveNVLinkDomainHealthReport:input_type -> forge.RemoveNVLinkDomainHealthReportRequest - 1016, // 1305: forge.Forge.ListHealthReportOverrides:input_type -> common.MachineId - 467, // 1306: forge.Forge.InsertHealthReportOverride:input_type -> forge.InsertMachineHealthReportRequest - 478, // 1307: forge.Forge.RemoveHealthReportOverride:input_type -> forge.RemoveMachineHealthReportRequest - 415, // 1308: forge.Forge.DpuAgentUpgradeCheck:input_type -> forge.DpuAgentUpgradeCheckRequest - 417, // 1309: forge.Forge.DpuAgentUpgradePolicyAction:input_type -> forge.DpuAgentUpgradePolicyRequest - 1088, // 1310: forge.Forge.LookupRecord:input_type -> dns.DnsResourceRecordLookupRequest - 1089, // 1311: forge.Forge.GetAllDomains:input_type -> dns.GetAllDomainsRequest - 1090, // 1312: forge.Forge.GetAllDomainMetadata:input_type -> dns.DomainMetadataRequest - 269, // 1313: forge.Forge.InvokeInstancePower:input_type -> forge.InstancePowerRequest - 442, // 1314: forge.Forge.ForgeAgentControl:input_type -> forge.ForgeAgentControlRequest - 444, // 1315: forge.Forge.DiscoverMachine:input_type -> forge.MachineDiscoveryInfo - 448, // 1316: forge.Forge.RenewMachineCertificate:input_type -> forge.MachineCertificateRenewRequest - 445, // 1317: forge.Forge.DiscoveryCompleted:input_type -> forge.MachineDiscoveryCompletedRequest - 446, // 1318: forge.Forge.CleanupMachineCompleted:input_type -> forge.MachineCleanupInfo - 453, // 1319: forge.Forge.ReportForgeScoutError:input_type -> forge.ForgeScoutErrorReport - 372, // 1320: forge.Forge.DiscoverDhcp:input_type -> forge.DhcpDiscovery - 373, // 1321: forge.Forge.ExpireDhcpLease:input_type -> forge.ExpireDhcpLeaseRequest - 342, // 1322: forge.Forge.AssignStaticAddress:input_type -> forge.AssignStaticAddressRequest - 344, // 1323: forge.Forge.RemoveStaticAddress:input_type -> forge.RemoveStaticAddressRequest - 346, // 1324: forge.Forge.FindInterfaceAddresses:input_type -> forge.FindInterfaceAddressesRequest - 341, // 1325: forge.Forge.FindInterfaces:input_type -> forge.InterfaceSearchQuery - 340, // 1326: forge.Forge.DeleteInterface:input_type -> forge.InterfaceDeleteQuery - 517, // 1327: forge.Forge.FindIpAddress:input_type -> forge.FindIpAddressRequest - 326, // 1328: forge.Forge.FindMachineIds:input_type -> forge.MachineSearchConfig - 325, // 1329: forge.Forge.FindMachinesByIds:input_type -> forge.MachinesByIdsRequest - 327, // 1330: forge.Forge.FindMachineStateHistories:input_type -> forge.MachineStateHistoriesRequest - 330, // 1331: forge.Forge.FindMachineHealthHistories:input_type -> forge.MachineHealthHistoriesRequest - 218, // 1332: forge.Forge.FindPowerShelfStateHistories:input_type -> forge.PowerShelfStateHistoriesRequest - 760, // 1333: forge.Forge.FindRackStateHistories:input_type -> forge.RackStateHistoriesRequest - 239, // 1334: forge.Forge.FindSwitchStateHistories:input_type -> forge.SwitchStateHistoriesRequest - 262, // 1335: forge.Forge.FindNetworkSegmentStateHistories:input_type -> forge.NetworkSegmentStateHistoriesRequest - 190, // 1336: forge.Forge.FindVpcPrefixStateHistories:input_type -> forge.VpcPrefixStateHistoriesRequest - 335, // 1337: forge.Forge.FindTenantOrganizationIds:input_type -> forge.TenantSearchFilter - 334, // 1338: forge.Forge.FindTenantsByOrganizationIds:input_type -> forge.TenantByOrganizationIdsRequest - 1077, // 1339: forge.Forge.FindConnectedDevicesByDpuMachineIds:input_type -> common.MachineIdList - 544, // 1340: forge.Forge.FindMachineIdsByBmcIps:input_type -> forge.BmcIpList - 545, // 1341: forge.Forge.FindMacAddressByBmcIp:input_type -> forge.BmcIp - 521, // 1342: forge.Forge.FindBmcIps:input_type -> forge.FindBmcIpsRequest - 519, // 1343: forge.Forge.IdentifyUuid:input_type -> forge.IdentifyUuidRequest - 522, // 1344: forge.Forge.IdentifyMac:input_type -> forge.IdentifyMacRequest - 524, // 1345: forge.Forge.IdentifySerial:input_type -> forge.IdentifySerialRequest - 438, // 1346: forge.Forge.GetBMCMetaData:input_type -> forge.BMCMetaDataGetRequest - 440, // 1347: forge.Forge.UpdateMachineCredentials:input_type -> forge.MachineCredentialsUpdateRequest - 455, // 1348: forge.Forge.GetPxeInstructions:input_type -> forge.PxeInstructionRequest - 459, // 1349: forge.Forge.GetCloudInitInstructions:input_type -> forge.CloudInitInstructionsRequest - 152, // 1350: forge.Forge.Echo:input_type -> forge.EchoRequest - 486, // 1351: forge.Forge.CreateTenant:input_type -> forge.CreateTenantRequest - 490, // 1352: forge.Forge.FindTenant:input_type -> forge.FindTenantRequest - 488, // 1353: forge.Forge.UpdateTenant:input_type -> forge.UpdateTenantRequest - 496, // 1354: forge.Forge.CreateTenantKeyset:input_type -> forge.CreateTenantKeysetRequest - 503, // 1355: forge.Forge.FindTenantKeysetIds:input_type -> forge.TenantKeysetSearchFilter - 505, // 1356: forge.Forge.FindTenantKeysetsByIds:input_type -> forge.TenantKeysetsByIdsRequest - 499, // 1357: forge.Forge.UpdateTenantKeyset:input_type -> forge.UpdateTenantKeysetRequest - 501, // 1358: forge.Forge.DeleteTenantKeyset:input_type -> forge.DeleteTenantKeysetRequest - 506, // 1359: forge.Forge.ValidateTenantPublicKey:input_type -> forge.ValidateTenantPublicKeyRequest - 379, // 1360: forge.Forge.GetBmcCredentials:input_type -> forge.GetBmcCredentialsRequest - 380, // 1361: forge.Forge.GetSwitchNvosCredentials:input_type -> forge.GetSwitchNvosCredentialsRequest - 413, // 1362: forge.Forge.GetAllManagedHostNetworkStatus:input_type -> forge.ManagedHostNetworkStatusRequest - 383, // 1363: forge.Forge.GetSiteExplorationReport:input_type -> forge.GetSiteExplorationRequest - 1091, // 1364: forge.Forge.GetSiteExplorerLastRun:input_type -> google.protobuf.Empty - 384, // 1365: forge.Forge.ClearSiteExplorationError:input_type -> forge.ClearSiteExplorationErrorRequest - 390, // 1366: forge.Forge.IsBmcInManagedHost:input_type -> forge.BmcEndpointRequest - 390, // 1367: forge.Forge.BmcCredentialStatus:input_type -> forge.BmcEndpointRequest - 390, // 1368: forge.Forge.Explore:input_type -> forge.BmcEndpointRequest - 385, // 1369: forge.Forge.ReExploreEndpoint:input_type -> forge.ReExploreEndpointRequest - 386, // 1370: forge.Forge.RefreshEndpointReport:input_type -> forge.RefreshEndpointReportRequest - 387, // 1371: forge.Forge.DeleteExploredEndpoint:input_type -> forge.DeleteExploredEndpointRequest - 388, // 1372: forge.Forge.PauseExploredEndpointRemediation:input_type -> forge.PauseExploredEndpointRemediationRequest - 1092, // 1373: forge.Forge.FindExploredEndpointIds:input_type -> site_explorer.ExploredEndpointSearchFilter - 1093, // 1374: forge.Forge.FindExploredEndpointsByIds:input_type -> site_explorer.ExploredEndpointsByIdsRequest - 1094, // 1375: forge.Forge.FindExploredManagedHostIds:input_type -> site_explorer.ExploredManagedHostSearchFilter - 1095, // 1376: forge.Forge.FindExploredManagedHostsByIds:input_type -> site_explorer.ExploredManagedHostsByIdsRequest - 1096, // 1377: forge.Forge.FindExploredMlxDeviceHostIds:input_type -> site_explorer.ExploredMlxDeviceHostSearchFilter - 1097, // 1378: forge.Forge.FindExploredMlxDevicesByIds:input_type -> site_explorer.ExploredMlxDevicesByIdsRequest - 394, // 1379: forge.Forge.UpdateMachineHardwareInfo:input_type -> forge.UpdateMachineHardwareInfoRequest - 419, // 1380: forge.Forge.AdminForceDeleteMachine:input_type -> forge.AdminForceDeleteMachineRequest - 508, // 1381: forge.Forge.AdminListResourcePools:input_type -> forge.ListResourcePoolsRequest - 511, // 1382: forge.Forge.AdminGrowResourcePool:input_type -> forge.GrowResourcePoolRequest - 356, // 1383: forge.Forge.UpdateMachineMetadata:input_type -> forge.MachineMetadataUpdateRequest - 357, // 1384: forge.Forge.UpdateRackMetadata:input_type -> forge.RackMetadataUpdateRequest - 358, // 1385: forge.Forge.UpdateSwitchMetadata:input_type -> forge.SwitchMetadataUpdateRequest - 359, // 1386: forge.Forge.UpdatePowerShelfMetadata:input_type -> forge.PowerShelfMetadataUpdateRequest - 774, // 1387: forge.Forge.UpdateMachineNvLinkInfo:input_type -> forge.UpdateMachineNvLinkInfoRequest - 515, // 1388: forge.Forge.SetMaintenance:input_type -> forge.MaintenanceRequest - 516, // 1389: forge.Forge.SetDynamicConfig:input_type -> forge.SetDynamicConfigRequest - 526, // 1390: forge.Forge.TriggerDpuReprovisioning:input_type -> forge.DpuReprovisioningRequest - 527, // 1391: forge.Forge.ListDpuWaitingForReprovisioning:input_type -> forge.DpuReprovisioningListRequest - 529, // 1392: forge.Forge.TriggerHostReprovisioning:input_type -> forge.HostReprovisioningRequest - 532, // 1393: forge.Forge.ListHostsWaitingForReprovisioning:input_type -> forge.HostReprovisioningListRequest - 530, // 1394: forge.Forge.TriggerBmcCredentialRotation:input_type -> forge.BmcCredentialRotationRequest - 531, // 1395: forge.Forge.TriggerUefiCredentialRotation:input_type -> forge.UefiCredentialRotationRequest - 1016, // 1396: forge.Forge.MarkManualFirmwareUpgradeComplete:input_type -> common.MachineId - 583, // 1397: forge.Forge.ReportScoutFirmwareUpgradeStatus:input_type -> forge.ScoutFirmwareUpgradeStatusRequest - 538, // 1398: forge.Forge.GetDpuInfoList:input_type -> forge.GetDpuInfoListRequest - 1039, // 1399: forge.Forge.GetMachineBootOverride:input_type -> common.MachineInterfaceId - 541, // 1400: forge.Forge.SetMachineBootOverride:input_type -> forge.MachineBootOverride - 1039, // 1401: forge.Forge.ClearMachineBootOverride:input_type -> common.MachineInterfaceId - 959, // 1402: forge.Forge.GetMachineBootInterfaces:input_type -> forge.GetMachineBootInterfacesRequest - 550, // 1403: forge.Forge.GetNetworkTopology:input_type -> forge.NetworkTopologyRequest - 551, // 1404: forge.Forge.FindNetworkDevicesByDeviceIds:input_type -> forge.NetworkDeviceIdList - 140, // 1405: forge.Forge.CreateCredential:input_type -> forge.CredentialCreationRequest - 141, // 1406: forge.Forge.DeleteCredential:input_type -> forge.CredentialDeletionRequest - 144, // 1407: forge.Forge.RotateCredential:input_type -> forge.RotateCredentialRequest - 146, // 1408: forge.Forge.GetCredentialRotationStatus:input_type -> forge.CredentialRotationStatusRequest - 966, // 1409: forge.Forge.GetContainerRegistryCredential:input_type -> forge.GetContainerRegistryCredentialRequest - 968, // 1410: forge.Forge.SetContainerRegistryCredential:input_type -> forge.SetContainerRegistryCredentialRequest - 1091, // 1411: forge.Forge.GetRouteServers:input_type -> google.protobuf.Empty - 553, // 1412: forge.Forge.AddRouteServers:input_type -> forge.RouteServers - 553, // 1413: forge.Forge.RemoveRouteServers:input_type -> forge.RouteServers - 553, // 1414: forge.Forge.ReplaceRouteServers:input_type -> forge.RouteServers - 360, // 1415: forge.Forge.UpdateAgentReportedInventory:input_type -> forge.DpuAgentInventoryReport - 318, // 1416: forge.Forge.UpdateInstancePhoneHomeLastContact:input_type -> forge.InstancePhoneHomeLastContactRequest - 556, // 1417: forge.Forge.SetHostUefiPassword:input_type -> forge.SetHostUefiPasswordRequest - 558, // 1418: forge.Forge.ClearHostUefiPassword:input_type -> forge.ClearHostUefiPasswordRequest - 571, // 1419: forge.Forge.AddExpectedMachine:input_type -> forge.ExpectedMachine - 572, // 1420: forge.Forge.DeleteExpectedMachine:input_type -> forge.ExpectedMachineRequest - 571, // 1421: forge.Forge.UpdateExpectedMachine:input_type -> forge.ExpectedMachine - 572, // 1422: forge.Forge.GetExpectedMachine:input_type -> forge.ExpectedMachineRequest - 1091, // 1423: forge.Forge.GetAllExpectedMachines:input_type -> google.protobuf.Empty - 573, // 1424: forge.Forge.ReplaceAllExpectedMachines:input_type -> forge.ExpectedMachineList - 1091, // 1425: forge.Forge.DeleteAllExpectedMachines:input_type -> google.protobuf.Empty - 1091, // 1426: forge.Forge.GetAllExpectedMachinesLinked:input_type -> google.protobuf.Empty - 1091, // 1427: forge.Forge.GetAllUnexpectedMachines:input_type -> google.protobuf.Empty - 578, // 1428: forge.Forge.CreateExpectedMachines:input_type -> forge.BatchExpectedMachineOperationRequest - 578, // 1429: forge.Forge.UpdateExpectedMachines:input_type -> forge.BatchExpectedMachineOperationRequest - 222, // 1430: forge.Forge.AddExpectedPowerShelf:input_type -> forge.ExpectedPowerShelf - 223, // 1431: forge.Forge.DeleteExpectedPowerShelf:input_type -> forge.ExpectedPowerShelfRequest - 222, // 1432: forge.Forge.UpdateExpectedPowerShelf:input_type -> forge.ExpectedPowerShelf - 223, // 1433: forge.Forge.GetExpectedPowerShelf:input_type -> forge.ExpectedPowerShelfRequest - 1091, // 1434: forge.Forge.GetAllExpectedPowerShelves:input_type -> google.protobuf.Empty - 224, // 1435: forge.Forge.ReplaceAllExpectedPowerShelves:input_type -> forge.ExpectedPowerShelfList - 1091, // 1436: forge.Forge.DeleteAllExpectedPowerShelves:input_type -> google.protobuf.Empty - 1091, // 1437: forge.Forge.GetAllExpectedPowerShelvesLinked:input_type -> google.protobuf.Empty - 244, // 1438: forge.Forge.AddExpectedSwitch:input_type -> forge.ExpectedSwitch - 245, // 1439: forge.Forge.DeleteExpectedSwitch:input_type -> forge.ExpectedSwitchRequest - 244, // 1440: forge.Forge.UpdateExpectedSwitch:input_type -> forge.ExpectedSwitch - 245, // 1441: forge.Forge.GetExpectedSwitch:input_type -> forge.ExpectedSwitchRequest - 1091, // 1442: forge.Forge.GetAllExpectedSwitches:input_type -> google.protobuf.Empty - 246, // 1443: forge.Forge.ReplaceAllExpectedSwitches:input_type -> forge.ExpectedSwitchList - 1091, // 1444: forge.Forge.DeleteAllExpectedSwitches:input_type -> google.protobuf.Empty - 1091, // 1445: forge.Forge.GetAllExpectedSwitchesLinked:input_type -> google.protobuf.Empty - 249, // 1446: forge.Forge.AddExpectedRack:input_type -> forge.ExpectedRack - 250, // 1447: forge.Forge.DeleteExpectedRack:input_type -> forge.ExpectedRackRequest - 249, // 1448: forge.Forge.UpdateExpectedRack:input_type -> forge.ExpectedRack - 250, // 1449: forge.Forge.GetExpectedRack:input_type -> forge.ExpectedRackRequest - 1091, // 1450: forge.Forge.GetAllExpectedRacks:input_type -> google.protobuf.Empty - 251, // 1451: forge.Forge.ReplaceAllExpectedRacks:input_type -> forge.ExpectedRackList - 1091, // 1452: forge.Forge.DeleteAllExpectedRacks:input_type -> google.protobuf.Empty - 138, // 1453: forge.Forge.AttestQuote:input_type -> forge.AttestQuoteRequest - 653, // 1454: forge.Forge.CreateInstanceType:input_type -> forge.CreateInstanceTypeRequest - 655, // 1455: forge.Forge.FindInstanceTypeIds:input_type -> forge.FindInstanceTypeIdsRequest - 657, // 1456: forge.Forge.FindInstanceTypesByIds:input_type -> forge.FindInstanceTypesByIdsRequest - 662, // 1457: forge.Forge.UpdateInstanceType:input_type -> forge.UpdateInstanceTypeRequest - 659, // 1458: forge.Forge.DeleteInstanceType:input_type -> forge.DeleteInstanceTypeRequest - 663, // 1459: forge.Forge.AssociateMachinesWithInstanceType:input_type -> forge.AssociateMachinesWithInstanceTypeRequest - 665, // 1460: forge.Forge.RemoveMachineInstanceTypeAssociation:input_type -> forge.RemoveMachineInstanceTypeAssociationRequest - 1098, // 1461: forge.Forge.CreateMeasurementBundle:input_type -> measured_boot.CreateMeasurementBundleRequest - 1099, // 1462: forge.Forge.DeleteMeasurementBundle:input_type -> measured_boot.DeleteMeasurementBundleRequest - 1100, // 1463: forge.Forge.RenameMeasurementBundle:input_type -> measured_boot.RenameMeasurementBundleRequest - 1101, // 1464: forge.Forge.UpdateMeasurementBundle:input_type -> measured_boot.UpdateMeasurementBundleRequest - 1102, // 1465: forge.Forge.ShowMeasurementBundle:input_type -> measured_boot.ShowMeasurementBundleRequest - 1103, // 1466: forge.Forge.ShowMeasurementBundles:input_type -> measured_boot.ShowMeasurementBundlesRequest - 1104, // 1467: forge.Forge.ListMeasurementBundles:input_type -> measured_boot.ListMeasurementBundlesRequest - 1105, // 1468: forge.Forge.ListMeasurementBundleMachines:input_type -> measured_boot.ListMeasurementBundleMachinesRequest - 1106, // 1469: forge.Forge.FindClosestBundleMatch:input_type -> measured_boot.FindClosestBundleMatchRequest - 1107, // 1470: forge.Forge.DeleteMeasurementJournal:input_type -> measured_boot.DeleteMeasurementJournalRequest - 1108, // 1471: forge.Forge.ShowMeasurementJournal:input_type -> measured_boot.ShowMeasurementJournalRequest - 1109, // 1472: forge.Forge.ShowMeasurementJournals:input_type -> measured_boot.ShowMeasurementJournalsRequest - 1110, // 1473: forge.Forge.ListMeasurementJournal:input_type -> measured_boot.ListMeasurementJournalRequest - 1111, // 1474: forge.Forge.AttestCandidateMachine:input_type -> measured_boot.AttestCandidateMachineRequest - 1112, // 1475: forge.Forge.ShowCandidateMachine:input_type -> measured_boot.ShowCandidateMachineRequest - 1113, // 1476: forge.Forge.ShowCandidateMachines:input_type -> measured_boot.ShowCandidateMachinesRequest - 1114, // 1477: forge.Forge.ListCandidateMachines:input_type -> measured_boot.ListCandidateMachinesRequest - 1115, // 1478: forge.Forge.CreateMeasurementSystemProfile:input_type -> measured_boot.CreateMeasurementSystemProfileRequest - 1116, // 1479: forge.Forge.DeleteMeasurementSystemProfile:input_type -> measured_boot.DeleteMeasurementSystemProfileRequest - 1117, // 1480: forge.Forge.RenameMeasurementSystemProfile:input_type -> measured_boot.RenameMeasurementSystemProfileRequest - 1118, // 1481: forge.Forge.ShowMeasurementSystemProfile:input_type -> measured_boot.ShowMeasurementSystemProfileRequest - 1119, // 1482: forge.Forge.ShowMeasurementSystemProfiles:input_type -> measured_boot.ShowMeasurementSystemProfilesRequest - 1120, // 1483: forge.Forge.ListMeasurementSystemProfiles:input_type -> measured_boot.ListMeasurementSystemProfilesRequest - 1121, // 1484: forge.Forge.ListMeasurementSystemProfileBundles:input_type -> measured_boot.ListMeasurementSystemProfileBundlesRequest - 1122, // 1485: forge.Forge.ListMeasurementSystemProfileMachines:input_type -> measured_boot.ListMeasurementSystemProfileMachinesRequest - 1123, // 1486: forge.Forge.CreateMeasurementReport:input_type -> measured_boot.CreateMeasurementReportRequest - 1124, // 1487: forge.Forge.DeleteMeasurementReport:input_type -> measured_boot.DeleteMeasurementReportRequest - 1125, // 1488: forge.Forge.PromoteMeasurementReport:input_type -> measured_boot.PromoteMeasurementReportRequest - 1126, // 1489: forge.Forge.RevokeMeasurementReport:input_type -> measured_boot.RevokeMeasurementReportRequest - 1127, // 1490: forge.Forge.ShowMeasurementReportForId:input_type -> measured_boot.ShowMeasurementReportForIdRequest - 1128, // 1491: forge.Forge.ShowMeasurementReportsForMachine:input_type -> measured_boot.ShowMeasurementReportsForMachineRequest - 1129, // 1492: forge.Forge.ShowMeasurementReports:input_type -> measured_boot.ShowMeasurementReportsRequest - 1130, // 1493: forge.Forge.ListMeasurementReport:input_type -> measured_boot.ListMeasurementReportRequest - 1131, // 1494: forge.Forge.MatchMeasurementReport:input_type -> measured_boot.MatchMeasurementReportRequest - 1132, // 1495: forge.Forge.ImportSiteMeasurements:input_type -> measured_boot.ImportSiteMeasurementsRequest - 1133, // 1496: forge.Forge.ExportSiteMeasurements:input_type -> measured_boot.ExportSiteMeasurementsRequest - 1134, // 1497: forge.Forge.AddMeasurementTrustedMachine:input_type -> measured_boot.AddMeasurementTrustedMachineRequest - 1135, // 1498: forge.Forge.RemoveMeasurementTrustedMachine:input_type -> measured_boot.RemoveMeasurementTrustedMachineRequest - 1136, // 1499: forge.Forge.AddMeasurementTrustedProfile:input_type -> measured_boot.AddMeasurementTrustedProfileRequest - 1137, // 1500: forge.Forge.RemoveMeasurementTrustedProfile:input_type -> measured_boot.RemoveMeasurementTrustedProfileRequest - 1138, // 1501: forge.Forge.ListMeasurementTrustedMachines:input_type -> measured_boot.ListMeasurementTrustedMachinesRequest - 1139, // 1502: forge.Forge.ListMeasurementTrustedProfiles:input_type -> measured_boot.ListMeasurementTrustedProfilesRequest - 1140, // 1503: forge.Forge.ListAttestationSummary:input_type -> measured_boot.ListAttestationSummaryRequest - 684, // 1504: forge.Forge.CreateNetworkSecurityGroup:input_type -> forge.CreateNetworkSecurityGroupRequest - 686, // 1505: forge.Forge.FindNetworkSecurityGroupIds:input_type -> forge.FindNetworkSecurityGroupIdsRequest - 688, // 1506: forge.Forge.FindNetworkSecurityGroupsByIds:input_type -> forge.FindNetworkSecurityGroupsByIdsRequest - 691, // 1507: forge.Forge.UpdateNetworkSecurityGroup:input_type -> forge.UpdateNetworkSecurityGroupRequest - 692, // 1508: forge.Forge.DeleteNetworkSecurityGroup:input_type -> forge.DeleteNetworkSecurityGroupRequest - 698, // 1509: forge.Forge.GetNetworkSecurityGroupPropagationStatus:input_type -> forge.GetNetworkSecurityGroupPropagationStatusRequest - 701, // 1510: forge.Forge.GetNetworkSecurityGroupAttachments:input_type -> forge.GetNetworkSecurityGroupAttachmentsRequest - 560, // 1511: forge.Forge.CreateOsImage:input_type -> forge.OsImageAttributes - 564, // 1512: forge.Forge.DeleteOsImage:input_type -> forge.DeleteOsImageRequest - 562, // 1513: forge.Forge.ListOsImage:input_type -> forge.ListOsImageRequest - 1028, // 1514: forge.Forge.GetOsImage:input_type -> common.UUID - 560, // 1515: forge.Forge.UpdateOsImage:input_type -> forge.OsImageAttributes - 566, // 1516: forge.Forge.GetIpxeTemplate:input_type -> forge.GetIpxeTemplateRequest - 567, // 1517: forge.Forge.ListIpxeTemplates:input_type -> forge.ListIpxeTemplatesRequest - 582, // 1518: forge.Forge.RebootCompleted:input_type -> forge.MachineRebootCompletedRequest - 587, // 1519: forge.Forge.PersistValidationResult:input_type -> forge.MachineValidationResultPostRequest - 589, // 1520: forge.Forge.GetMachineValidationResults:input_type -> forge.MachineValidationGetRequest - 584, // 1521: forge.Forge.MachineValidationCompleted:input_type -> forge.MachineValidationCompletedRequest - 592, // 1522: forge.Forge.MachineSetAutoUpdate:input_type -> forge.MachineSetAutoUpdateRequest - 594, // 1523: forge.Forge.GetMachineValidationExternalConfig:input_type -> forge.GetMachineValidationExternalConfigRequest - 597, // 1524: forge.Forge.GetMachineValidationExternalConfigs:input_type -> forge.GetMachineValidationExternalConfigsRequest - 599, // 1525: forge.Forge.AddUpdateMachineValidationExternalConfig:input_type -> forge.AddUpdateMachineValidationExternalConfigRequest - 616, // 1526: forge.Forge.GetMachineValidationRuns:input_type -> forge.MachineValidationRunListGetRequest - 617, // 1527: forge.Forge.FindMachineValidationRunItemIds:input_type -> forge.MachineValidationRunItemSearchFilter - 619, // 1528: forge.Forge.FindMachineValidationRunItemsByIds:input_type -> forge.MachineValidationRunItemsByIdsRequest - 622, // 1529: forge.Forge.GetMachineValidationAttempt:input_type -> forge.MachineValidationAttemptGetRequest - 624, // 1530: forge.Forge.HeartbeatMachineValidationRun:input_type -> forge.MachineValidationHeartbeatRequest - 600, // 1531: forge.Forge.RemoveMachineValidationExternalConfig:input_type -> forge.RemoveMachineValidationExternalConfigRequest - 628, // 1532: forge.Forge.GetMachineValidationTests:input_type -> forge.MachineValidationTestsGetRequest - 630, // 1533: forge.Forge.AddMachineValidationTest:input_type -> forge.MachineValidationTestAddRequest - 629, // 1534: forge.Forge.UpdateMachineValidationTest:input_type -> forge.MachineValidationTestUpdateRequest - 633, // 1535: forge.Forge.MachineValidationTestVerfied:input_type -> forge.MachineValidationTestVerfiedRequest - 637, // 1536: forge.Forge.MachineValidationTestNextVersion:input_type -> forge.MachineValidationTestNextVersionRequest - 638, // 1537: forge.Forge.MachineValidationTestEnableDisableTest:input_type -> forge.MachineValidationTestEnableDisableTestRequest - 640, // 1538: forge.Forge.UpdateMachineValidationRun:input_type -> forge.MachineValidationRunRequest - 432, // 1539: forge.Forge.AdminBmcReset:input_type -> forge.AdminBmcResetRequest - 611, // 1540: forge.Forge.AdminPowerControl:input_type -> forge.AdminPowerControlRequest - 390, // 1541: forge.Forge.DisableSecureBoot:input_type -> forge.BmcEndpointRequest - 422, // 1542: forge.Forge.Lockdown:input_type -> forge.LockdownRequest - 424, // 1543: forge.Forge.LockdownStatus:input_type -> forge.LockdownStatusRequest - 426, // 1544: forge.Forge.MachineSetup:input_type -> forge.MachineSetupRequest - 428, // 1545: forge.Forge.SetDpuFirstBootOrder:input_type -> forge.SetDpuFirstBootOrderRequest - 807, // 1546: forge.Forge.CreateBmcUser:input_type -> forge.CreateBmcUserRequest - 809, // 1547: forge.Forge.DeleteBmcUser:input_type -> forge.DeleteBmcUserRequest - 811, // 1548: forge.Forge.SetBmcRootPassword:input_type -> forge.SetBmcRootPasswordRequest - 813, // 1549: forge.Forge.ProbeBmcVendor:input_type -> forge.ProbeBmcVendorRequest - 434, // 1550: forge.Forge.EnableInfiniteBoot:input_type -> forge.EnableInfiniteBootRequest - 436, // 1551: forge.Forge.IsInfiniteBootEnabled:input_type -> forge.IsInfiniteBootEnabledRequest - 601, // 1552: forge.Forge.OnDemandMachineValidation:input_type -> forge.MachineValidationOnDemandRequest - 609, // 1553: forge.Forge.OnDemandRackMaintenance:input_type -> forge.RackMaintenanceOnDemandRequest - 134, // 1554: forge.Forge.TpmAddCaCert:input_type -> forge.TpmCaCert - 1091, // 1555: forge.Forge.TpmShowCaCerts:input_type -> google.protobuf.Empty - 1091, // 1556: forge.Forge.TpmShowUnmatchedEkCerts:input_type -> google.protobuf.Empty - 131, // 1557: forge.Forge.TpmDeleteCaCert:input_type -> forge.TpmCaCertId - 667, // 1558: forge.Forge.RedfishBrowse:input_type -> forge.RedfishBrowseRequest - 669, // 1559: forge.Forge.RedfishListActions:input_type -> forge.RedfishListActionsRequest - 674, // 1560: forge.Forge.RedfishCreateAction:input_type -> forge.RedfishCreateActionRequest - 676, // 1561: forge.Forge.RedfishApproveAction:input_type -> forge.RedfishActionID - 676, // 1562: forge.Forge.RedfishApplyAction:input_type -> forge.RedfishActionID - 676, // 1563: forge.Forge.RedfishCancelAction:input_type -> forge.RedfishActionID - 680, // 1564: forge.Forge.UfmBrowse:input_type -> forge.UfmBrowseRequest - 704, // 1565: forge.Forge.GetDesiredFirmwareVersions:input_type -> forge.GetDesiredFirmwareVersionsRequest - 817, // 1566: forge.Forge.UpsertHostFirmwareConfig:input_type -> forge.UpsertHostFirmwareConfigRequest - 818, // 1567: forge.Forge.DeleteHostFirmwareConfig:input_type -> forge.DeleteHostFirmwareConfigRequest - 720, // 1568: forge.Forge.CreateSku:input_type -> forge.SkuList - 1016, // 1569: forge.Forge.GenerateSkuFromMachine:input_type -> common.MachineId - 1016, // 1570: forge.Forge.VerifySkuForMachine:input_type -> common.MachineId - 718, // 1571: forge.Forge.AssignSkuToMachine:input_type -> forge.SkuMachinePair - 719, // 1572: forge.Forge.RemoveSkuAssociation:input_type -> forge.RemoveSkuRequest - 721, // 1573: forge.Forge.DeleteSku:input_type -> forge.SkuIdList - 1091, // 1574: forge.Forge.GetAllSkuIds:input_type -> google.protobuf.Empty - 723, // 1575: forge.Forge.FindSkusByIds:input_type -> forge.SkusByIdsRequest - 733, // 1576: forge.Forge.UpdateSkuMetadata:input_type -> forge.SkuUpdateMetadataRequest - 717, // 1577: forge.Forge.ReplaceSku:input_type -> forge.Sku - 402, // 1578: forge.Forge.GetManagedHostQuarantineState:input_type -> forge.GetManagedHostQuarantineStateRequest - 404, // 1579: forge.Forge.SetManagedHostQuarantineState:input_type -> forge.SetManagedHostQuarantineStateRequest - 406, // 1580: forge.Forge.ClearManagedHostQuarantineState:input_type -> forge.ClearManagedHostQuarantineStateRequest - 1016, // 1581: forge.Forge.ResetHostReprovisioning:input_type -> common.MachineId - 393, // 1582: forge.Forge.CopyBfbToDpuRshim:input_type -> forge.CopyBfbToDpuRshimRequest - 1091, // 1583: forge.Forge.GetAllDpaInterfaceIds:input_type -> google.protobuf.Empty - 728, // 1584: forge.Forge.FindDpaInterfacesByIds:input_type -> forge.DpaInterfacesByIdsRequest - 726, // 1585: forge.Forge.CreateDpaInterface:input_type -> forge.DpaInterfaceCreationRequest - 726, // 1586: forge.Forge.EnsureDpaInterface:input_type -> forge.DpaInterfaceCreationRequest - 731, // 1587: forge.Forge.DeleteDpaInterface:input_type -> forge.DpaInterfaceDeletionRequest - 734, // 1588: forge.Forge.GetPowerOptions:input_type -> forge.PowerOptionRequest - 735, // 1589: forge.Forge.UpdatePowerOption:input_type -> forge.PowerOptionUpdateRequest - 390, // 1590: forge.Forge.AllowIngestionAndPowerOn:input_type -> forge.BmcEndpointRequest - 390, // 1591: forge.Forge.DetermineMachineIngestionState:input_type -> forge.BmcEndpointRequest - 754, // 1592: forge.Forge.FindRackIds:input_type -> forge.RackSearchFilter - 756, // 1593: forge.Forge.FindRacksByIds:input_type -> forge.RacksByIdsRequest - 751, // 1594: forge.Forge.GetRack:input_type -> forge.GetRackRequest - 761, // 1595: forge.Forge.DeleteRack:input_type -> forge.DeleteRackRequest - 762, // 1596: forge.Forge.AdminForceDeleteRack:input_type -> forge.AdminForceDeleteRackRequest - 769, // 1597: forge.Forge.GetRackProfile:input_type -> forge.GetRackProfileRequest - 740, // 1598: forge.Forge.CreateComputeAllocation:input_type -> forge.CreateComputeAllocationRequest - 742, // 1599: forge.Forge.FindComputeAllocationIds:input_type -> forge.FindComputeAllocationIdsRequest - 744, // 1600: forge.Forge.FindComputeAllocationsByIds:input_type -> forge.FindComputeAllocationsByIdsRequest - 747, // 1601: forge.Forge.UpdateComputeAllocation:input_type -> forge.UpdateComputeAllocationRequest - 748, // 1602: forge.Forge.DeleteComputeAllocation:input_type -> forge.DeleteComputeAllocationRequest - 815, // 1603: forge.Forge.SetFirmwareUpdateTimeWindow:input_type -> forge.SetFirmwareUpdateTimeWindowRequest - 824, // 1604: forge.Forge.ListHostFirmware:input_type -> forge.ListHostFirmwareRequest - 1141, // 1605: forge.Forge.PublishMlxDeviceReport:input_type -> mlx_device.PublishMlxDeviceReportRequest - 1142, // 1606: forge.Forge.PublishMlxObservationReport:input_type -> mlx_device.PublishMlxObservationReportRequest - 827, // 1607: forge.Forge.TrimTable:input_type -> forge.TrimTableRequest - 1091, // 1608: forge.Forge.ListNvlinkNmxcEndpoints:input_type -> google.protobuf.Empty - 829, // 1609: forge.Forge.CreateNvlinkNmxcEndpoint:input_type -> forge.NvlinkNmxcEndpoint - 829, // 1610: forge.Forge.UpdateNvlinkNmxcEndpoint:input_type -> forge.NvlinkNmxcEndpoint - 831, // 1611: forge.Forge.DeleteNvlinkNmxcEndpoint:input_type -> forge.DeleteNvlinkNmxcEndpointRequest - 832, // 1612: forge.Forge.CreateRemediation:input_type -> forge.CreateRemediationRequest - 837, // 1613: forge.Forge.ApproveRemediation:input_type -> forge.ApproveRemediationRequest - 838, // 1614: forge.Forge.RevokeRemediation:input_type -> forge.RevokeRemediationRequest - 839, // 1615: forge.Forge.EnableRemediation:input_type -> forge.EnableRemediationRequest - 840, // 1616: forge.Forge.DisableRemediation:input_type -> forge.DisableRemediationRequest - 1091, // 1617: forge.Forge.FindRemediationIds:input_type -> google.protobuf.Empty - 834, // 1618: forge.Forge.FindRemediationsByIds:input_type -> forge.RemediationIdList - 841, // 1619: forge.Forge.FindAppliedRemediationIds:input_type -> forge.FindAppliedRemediationIdsRequest - 843, // 1620: forge.Forge.FindAppliedRemediations:input_type -> forge.FindAppliedRemediationsRequest - 846, // 1621: forge.Forge.GetNextRemediationForMachine:input_type -> forge.GetNextRemediationForMachineRequest - 848, // 1622: forge.Forge.RemediationApplied:input_type -> forge.RemediationAppliedRequest - 850, // 1623: forge.Forge.SetPrimaryDpu:input_type -> forge.SetPrimaryDpuRequest - 851, // 1624: forge.Forge.SetPrimaryInterface:input_type -> forge.SetPrimaryInterfaceRequest - 857, // 1625: forge.Forge.CreateDpuExtensionService:input_type -> forge.CreateDpuExtensionServiceRequest - 858, // 1626: forge.Forge.UpdateDpuExtensionService:input_type -> forge.UpdateDpuExtensionServiceRequest - 859, // 1627: forge.Forge.DeleteDpuExtensionService:input_type -> forge.DeleteDpuExtensionServiceRequest - 861, // 1628: forge.Forge.FindDpuExtensionServiceIds:input_type -> forge.DpuExtensionServiceSearchFilter - 863, // 1629: forge.Forge.FindDpuExtensionServicesByIds:input_type -> forge.DpuExtensionServicesByIdsRequest - 865, // 1630: forge.Forge.GetDpuExtensionServiceVersionsInfo:input_type -> forge.GetDpuExtensionServiceVersionsInfoRequest - 867, // 1631: forge.Forge.FindInstancesByDpuExtensionService:input_type -> forge.FindInstancesByDpuExtensionServiceRequest - 106, // 1632: forge.Forge.TriggerMachineAttestation:input_type -> forge.SpdmMachineAttestationTriggerRequest - 1016, // 1633: forge.Forge.CancelMachineAttestation:input_type -> common.MachineId - 107, // 1634: forge.Forge.ListAttestationMachines:input_type -> forge.SpdmListAttestationMachinesRequest - 1016, // 1635: forge.Forge.GetAttestationMachine:input_type -> common.MachineId - 109, // 1636: forge.Forge.SignMachineIdentity:input_type -> forge.MachineIdentityRequest - 111, // 1637: forge.Forge.GetTenantIdentityConfiguration:input_type -> forge.GetTenantIdentityConfigRequest - 114, // 1638: forge.Forge.SetTenantIdentityConfiguration:input_type -> forge.SetTenantIdentityConfigRequest - 111, // 1639: forge.Forge.DeleteTenantIdentityConfiguration:input_type -> forge.GetTenantIdentityConfigRequest - 119, // 1640: forge.Forge.GetTokenDelegation:input_type -> forge.GetTokenDelegationRequest - 121, // 1641: forge.Forge.SetTokenDelegation:input_type -> forge.TokenDelegationRequest - 119, // 1642: forge.Forge.DeleteTokenDelegation:input_type -> forge.GetTokenDelegationRequest - 122, // 1643: forge.Forge.ReencryptTenantIdentitySecrets:input_type -> forge.ReencryptTenantIdentitySecretsRequest - 127, // 1644: forge.Forge.GetJWKS:input_type -> forge.JwksRequest - 128, // 1645: forge.Forge.GetOpenIDConfiguration:input_type -> forge.OpenIdConfigRequest - 874, // 1646: forge.Forge.ScoutStream:input_type -> forge.ScoutStreamApiBoundMessage - 877, // 1647: forge.Forge.ScoutStreamShowConnections:input_type -> forge.ScoutStreamShowConnectionsRequest - 879, // 1648: forge.Forge.ScoutStreamDisconnect:input_type -> forge.ScoutStreamDisconnectRequest - 881, // 1649: forge.Forge.ScoutStreamPing:input_type -> forge.ScoutStreamAdminPingRequest - 1143, // 1650: forge.Forge.MlxAdminProfileSync:input_type -> mlx_device.MlxAdminProfileSyncRequest - 1144, // 1651: forge.Forge.MlxAdminProfileShow:input_type -> mlx_device.MlxAdminProfileShowRequest - 1145, // 1652: forge.Forge.MlxAdminProfileCompare:input_type -> mlx_device.MlxAdminProfileCompareRequest - 1146, // 1653: forge.Forge.MlxAdminProfileList:input_type -> mlx_device.MlxAdminProfileListRequest - 1147, // 1654: forge.Forge.MlxAdminLockdownLock:input_type -> mlx_device.MlxAdminLockdownLockRequest - 1148, // 1655: forge.Forge.MlxAdminLockdownUnlock:input_type -> mlx_device.MlxAdminLockdownUnlockRequest - 1149, // 1656: forge.Forge.MlxAdminLockdownStatus:input_type -> mlx_device.MlxAdminLockdownStatusRequest - 1150, // 1657: forge.Forge.MlxAdminShowDevice:input_type -> mlx_device.MlxAdminDeviceInfoRequest - 1151, // 1658: forge.Forge.MlxAdminShowMachine:input_type -> mlx_device.MlxAdminDeviceReportRequest - 1152, // 1659: forge.Forge.MlxAdminRegistryList:input_type -> mlx_device.MlxAdminRegistryListRequest - 1153, // 1660: forge.Forge.MlxAdminRegistryShow:input_type -> mlx_device.MlxAdminRegistryShowRequest - 1154, // 1661: forge.Forge.MlxAdminConfigQuery:input_type -> mlx_device.MlxAdminConfigQueryRequest - 1155, // 1662: forge.Forge.MlxAdminConfigSet:input_type -> mlx_device.MlxAdminConfigSetRequest - 1156, // 1663: forge.Forge.MlxAdminConfigSync:input_type -> mlx_device.MlxAdminConfigSyncRequest - 1157, // 1664: forge.Forge.MlxAdminConfigCompare:input_type -> mlx_device.MlxAdminConfigCompareRequest - 791, // 1665: forge.Forge.FindNVLinkPartitionIds:input_type -> forge.NVLinkPartitionSearchFilter - 792, // 1666: forge.Forge.FindNVLinkPartitionsByIds:input_type -> forge.NVLinkPartitionsByIdsRequest - 164, // 1667: forge.Forge.NVLinkPartitionsForTenant:input_type -> forge.TenantSearchQuery - 802, // 1668: forge.Forge.FindNVLinkLogicalPartitionIds:input_type -> forge.NVLinkLogicalPartitionSearchFilter - 803, // 1669: forge.Forge.FindNVLinkLogicalPartitionsByIds:input_type -> forge.NVLinkLogicalPartitionsByIdsRequest - 799, // 1670: forge.Forge.CreateNVLinkLogicalPartition:input_type -> forge.NVLinkLogicalPartitionCreationRequest - 805, // 1671: forge.Forge.UpdateNVLinkLogicalPartition:input_type -> forge.NVLinkLogicalPartitionUpdateRequest - 800, // 1672: forge.Forge.DeleteNVLinkLogicalPartition:input_type -> forge.NVLinkLogicalPartitionDeletionRequest - 164, // 1673: forge.Forge.NVLinkLogicalPartitionsForTenant:input_type -> forge.TenantSearchQuery - 895, // 1674: forge.Forge.GetMachinePositionInfo:input_type -> forge.MachinePositionQuery - 785, // 1675: forge.Forge.NmxcBrowse:input_type -> forge.NmxcBrowseRequest - 898, // 1676: forge.Forge.ModifyDPFState:input_type -> forge.ModifyDPFStateRequest - 900, // 1677: forge.Forge.GetDPFState:input_type -> forge.GetDPFStateRequest - 901, // 1678: forge.Forge.GetDPFHostSnapshot:input_type -> forge.GetDPFHostSnapshotRequest - 903, // 1679: forge.Forge.GetDPFServiceVersions:input_type -> forge.GetDPFServiceVersionsRequest - 912, // 1680: forge.Forge.ComponentPowerControl:input_type -> forge.ComponentPowerControlRequest - 914, // 1681: forge.Forge.ComponentConfigureSwitchCertificate:input_type -> forge.ComponentConfigureSwitchCertificateRequest - 909, // 1682: forge.Forge.GetComponentInventory:input_type -> forge.GetComponentInventoryRequest - 921, // 1683: forge.Forge.UpdateComponentFirmware:input_type -> forge.UpdateComponentFirmwareRequest - 923, // 1684: forge.Forge.GetComponentFirmwareStatus:input_type -> forge.GetComponentFirmwareStatusRequest - 925, // 1685: forge.Forge.ListComponentFirmwareVersions:input_type -> forge.ListComponentFirmwareVersionsRequest - 942, // 1686: forge.Forge.CreateOperatingSystem:input_type -> forge.CreateOperatingSystemRequest - 1036, // 1687: forge.Forge.GetOperatingSystem:input_type -> common.OperatingSystemId - 945, // 1688: forge.Forge.UpdateOperatingSystem:input_type -> forge.UpdateOperatingSystemRequest - 946, // 1689: forge.Forge.DeleteOperatingSystem:input_type -> forge.DeleteOperatingSystemRequest - 948, // 1690: forge.Forge.FindOperatingSystemIds:input_type -> forge.OperatingSystemSearchFilter - 950, // 1691: forge.Forge.FindOperatingSystemsByIds:input_type -> forge.OperatingSystemsByIdsRequest - 952, // 1692: forge.Forge.GetOperatingSystemCachableIpxeTemplateArtifacts:input_type -> forge.GetOperatingSystemCachableIpxeTemplateArtifactsRequest - 955, // 1693: forge.Forge.UpdateOperatingSystemCachableIpxeTemplateArtifacts:input_type -> forge.UpdateOperatingSystemIpxeTemplateArtifactRequest - 957, // 1694: forge.Forge.ReWrapSecrets:input_type -> forge.ReWrapSecretsRequest - 150, // 1695: forge.Forge.Version:output_type -> forge.BuildInfo - 1076, // 1696: forge.Forge.CreateDomain:output_type -> dns.Domain - 1076, // 1697: forge.Forge.UpdateDomain:output_type -> dns.Domain - 1158, // 1698: forge.Forge.DeleteDomain:output_type -> dns.DomainDeletionResult - 1159, // 1699: forge.Forge.FindDomain:output_type -> dns.DomainList - 889, // 1700: forge.Forge.CreateDomainLegacy:output_type -> forge.DomainLegacy - 889, // 1701: forge.Forge.UpdateDomainLegacy:output_type -> forge.DomainLegacy - 892, // 1702: forge.Forge.DeleteDomainLegacy:output_type -> forge.DomainDeletionResultLegacy - 890, // 1703: forge.Forge.FindDomainLegacy:output_type -> forge.DomainListLegacy - 170, // 1704: forge.Forge.CreateVpc:output_type -> forge.Vpc - 173, // 1705: forge.Forge.UpdateVpc:output_type -> forge.VpcUpdateResult - 175, // 1706: forge.Forge.UpdateVpcVirtualization:output_type -> forge.VpcUpdateVirtualizationResult - 177, // 1707: forge.Forge.DeleteVpc:output_type -> forge.VpcDeletionResult - 162, // 1708: forge.Forge.FindVpcIds:output_type -> forge.VpcIdList - 178, // 1709: forge.Forge.FindVpcsByIds:output_type -> forge.VpcList - 930, // 1710: forge.Forge.CreateSpxPartition:output_type -> forge.SpxPartition - 933, // 1711: forge.Forge.DeleteSpxPartition:output_type -> forge.SpxPartitionDeletionResult - 931, // 1712: forge.Forge.FindSpxPartitionIds:output_type -> forge.SpxPartitionIdList - 935, // 1713: forge.Forge.FindSpxPartitionsByIds:output_type -> forge.SpxPartitionList - 179, // 1714: forge.Forge.CreateVpcPrefix:output_type -> forge.VpcPrefix - 185, // 1715: forge.Forge.SearchVpcPrefixes:output_type -> forge.VpcPrefixIdList - 186, // 1716: forge.Forge.GetVpcPrefixes:output_type -> forge.VpcPrefixList - 179, // 1717: forge.Forge.UpdateVpcPrefix:output_type -> forge.VpcPrefix - 189, // 1718: forge.Forge.DeleteVpcPrefix:output_type -> forge.VpcPrefixDeletionResult - 974, // 1719: forge.Forge.FindSitePrefixIds:output_type -> forge.SitePrefixIdList - 975, // 1720: forge.Forge.FindSitePrefixesByIds:output_type -> forge.SitePrefixList - 191, // 1721: forge.Forge.CreateVpcPeering:output_type -> forge.VpcPeering - 192, // 1722: forge.Forge.FindVpcPeeringIds:output_type -> forge.VpcPeeringIdList - 193, // 1723: forge.Forge.FindVpcPeeringsByIds:output_type -> forge.VpcPeeringList - 198, // 1724: forge.Forge.DeleteVpcPeering:output_type -> forge.VpcPeeringDeletionResult - 265, // 1725: forge.Forge.FindNetworkSegmentIds:output_type -> forge.NetworkSegmentIdList - 376, // 1726: forge.Forge.FindNetworkSegmentsByIds:output_type -> forge.NetworkSegmentList - 257, // 1727: forge.Forge.CreateNetworkSegment:output_type -> forge.NetworkSegment - 257, // 1728: forge.Forge.AttachNetworkSegmentToVpc:output_type -> forge.NetworkSegment - 261, // 1729: forge.Forge.DeleteNetworkSegment:output_type -> forge.NetworkSegmentDeletionResult - 376, // 1730: forge.Forge.NetworkSegmentsForVpc:output_type -> forge.NetworkSegmentList - 209, // 1731: forge.Forge.FindIBPartitionIds:output_type -> forge.IBPartitionIdList - 202, // 1732: forge.Forge.FindIBPartitionsByIds:output_type -> forge.IBPartitionList - 201, // 1733: forge.Forge.CreateIBPartition:output_type -> forge.IBPartition - 201, // 1734: forge.Forge.UpdateIBPartition:output_type -> forge.IBPartition - 206, // 1735: forge.Forge.DeleteIBPartition:output_type -> forge.IBPartitionDeletionResult - 202, // 1736: forge.Forge.IBPartitionsForTenant:output_type -> forge.IBPartitionList - 213, // 1737: forge.Forge.FindPowerShelves:output_type -> forge.PowerShelfList - 908, // 1738: forge.Forge.FindPowerShelfIds:output_type -> forge.PowerShelfIdList - 213, // 1739: forge.Forge.FindPowerShelvesByIds:output_type -> forge.PowerShelfList - 216, // 1740: forge.Forge.DeletePowerShelf:output_type -> forge.PowerShelfDeletionResult - 940, // 1741: forge.Forge.AdminForceDeletePowerShelf:output_type -> forge.AdminForceDeletePowerShelfResponse - 1091, // 1742: forge.Forge.SetPowerShelfMaintenance:output_type -> google.protobuf.Empty - 233, // 1743: forge.Forge.FindSwitches:output_type -> forge.SwitchList - 907, // 1744: forge.Forge.FindSwitchIds:output_type -> forge.SwitchIdList - 233, // 1745: forge.Forge.FindSwitchesByIds:output_type -> forge.SwitchList - 236, // 1746: forge.Forge.DeleteSwitch:output_type -> forge.SwitchDeletionResult - 938, // 1747: forge.Forge.AdminForceDeleteSwitch:output_type -> forge.AdminForceDeleteSwitchResponse - 253, // 1748: forge.Forge.FindIBFabricIds:output_type -> forge.IBFabricIdList - 306, // 1749: forge.Forge.AllocateInstance:output_type -> forge.Instance - 279, // 1750: forge.Forge.AllocateInstances:output_type -> forge.BatchInstanceAllocationResponse - 324, // 1751: forge.Forge.ReleaseInstance:output_type -> forge.InstanceReleaseResult - 306, // 1752: forge.Forge.UpdateInstanceOperatingSystem:output_type -> forge.Instance - 306, // 1753: forge.Forge.UpdateInstanceConfig:output_type -> forge.Instance - 275, // 1754: forge.Forge.FindInstanceIds:output_type -> forge.InstanceIdList - 271, // 1755: forge.Forge.FindInstancesByIds:output_type -> forge.InstanceList - 271, // 1756: forge.Forge.FindInstanceByMachineID:output_type -> forge.InstanceList - 397, // 1757: forge.Forge.GetManagedHostNetworkConfig:output_type -> forge.ManagedHostNetworkConfigResponse - 1091, // 1758: forge.Forge.RecordDpuNetworkStatus:output_type -> google.protobuf.Empty - 477, // 1759: forge.Forge.ListMachineHealthReports:output_type -> forge.ListHealthReportResponse - 1091, // 1760: forge.Forge.InsertMachineHealthReport:output_type -> google.protobuf.Empty - 1091, // 1761: forge.Forge.RemoveMachineHealthReport:output_type -> google.protobuf.Empty - 477, // 1762: forge.Forge.ListRackHealthReports:output_type -> forge.ListHealthReportResponse - 1091, // 1763: forge.Forge.InsertRackHealthReport:output_type -> google.protobuf.Empty - 1091, // 1764: forge.Forge.RemoveRackHealthReport:output_type -> google.protobuf.Empty - 477, // 1765: forge.Forge.ListSwitchHealthReports:output_type -> forge.ListHealthReportResponse - 1091, // 1766: forge.Forge.InsertSwitchHealthReport:output_type -> google.protobuf.Empty - 1091, // 1767: forge.Forge.RemoveSwitchHealthReport:output_type -> google.protobuf.Empty - 477, // 1768: forge.Forge.ListPowerShelfHealthReports:output_type -> forge.ListHealthReportResponse - 1091, // 1769: forge.Forge.InsertPowerShelfHealthReport:output_type -> google.protobuf.Empty - 1091, // 1770: forge.Forge.RemovePowerShelfHealthReport:output_type -> google.protobuf.Empty - 477, // 1771: forge.Forge.ListNVLinkDomainHealthReports:output_type -> forge.ListHealthReportResponse - 1091, // 1772: forge.Forge.InsertNVLinkDomainHealthReport:output_type -> google.protobuf.Empty - 1091, // 1773: forge.Forge.RemoveNVLinkDomainHealthReport:output_type -> google.protobuf.Empty - 477, // 1774: forge.Forge.ListHealthReportOverrides:output_type -> forge.ListHealthReportResponse - 1091, // 1775: forge.Forge.InsertHealthReportOverride:output_type -> google.protobuf.Empty - 1091, // 1776: forge.Forge.RemoveHealthReportOverride:output_type -> google.protobuf.Empty - 416, // 1777: forge.Forge.DpuAgentUpgradeCheck:output_type -> forge.DpuAgentUpgradeCheckResponse - 418, // 1778: forge.Forge.DpuAgentUpgradePolicyAction:output_type -> forge.DpuAgentUpgradePolicyResponse - 1160, // 1779: forge.Forge.LookupRecord:output_type -> dns.DnsResourceRecordLookupResponse - 1161, // 1780: forge.Forge.GetAllDomains:output_type -> dns.GetAllDomainsResponse - 1162, // 1781: forge.Forge.GetAllDomainMetadata:output_type -> dns.DomainMetadataResponse - 270, // 1782: forge.Forge.InvokeInstancePower:output_type -> forge.InstancePowerResult - 443, // 1783: forge.Forge.ForgeAgentControl:output_type -> forge.ForgeAgentControlResponse - 450, // 1784: forge.Forge.DiscoverMachine:output_type -> forge.MachineDiscoveryResult - 449, // 1785: forge.Forge.RenewMachineCertificate:output_type -> forge.MachineCertificateResult - 451, // 1786: forge.Forge.DiscoveryCompleted:output_type -> forge.MachineDiscoveryCompletedResponse - 452, // 1787: forge.Forge.CleanupMachineCompleted:output_type -> forge.MachineCleanupResult - 454, // 1788: forge.Forge.ReportForgeScoutError:output_type -> forge.ForgeScoutErrorReportResult - 375, // 1789: forge.Forge.DiscoverDhcp:output_type -> forge.DhcpRecord - 374, // 1790: forge.Forge.ExpireDhcpLease:output_type -> forge.ExpireDhcpLeaseResponse - 343, // 1791: forge.Forge.AssignStaticAddress:output_type -> forge.AssignStaticAddressResponse - 345, // 1792: forge.Forge.RemoveStaticAddress:output_type -> forge.RemoveStaticAddressResponse - 348, // 1793: forge.Forge.FindInterfaceAddresses:output_type -> forge.FindInterfaceAddressesResponse - 338, // 1794: forge.Forge.FindInterfaces:output_type -> forge.InterfaceList - 1091, // 1795: forge.Forge.DeleteInterface:output_type -> google.protobuf.Empty - 518, // 1796: forge.Forge.FindIpAddress:output_type -> forge.FindIpAddressResponse - 1077, // 1797: forge.Forge.FindMachineIds:output_type -> common.MachineIdList - 339, // 1798: forge.Forge.FindMachinesByIds:output_type -> forge.MachineList - 328, // 1799: forge.Forge.FindMachineStateHistories:output_type -> forge.MachineStateHistories - 331, // 1800: forge.Forge.FindMachineHealthHistories:output_type -> forge.HealthHistories - 240, // 1801: forge.Forge.FindPowerShelfStateHistories:output_type -> forge.StateHistories - 240, // 1802: forge.Forge.FindRackStateHistories:output_type -> forge.StateHistories - 240, // 1803: forge.Forge.FindSwitchStateHistories:output_type -> forge.StateHistories - 240, // 1804: forge.Forge.FindNetworkSegmentStateHistories:output_type -> forge.StateHistories - 240, // 1805: forge.Forge.FindVpcPrefixStateHistories:output_type -> forge.StateHistories - 337, // 1806: forge.Forge.FindTenantOrganizationIds:output_type -> forge.TenantOrganizationIdList - 336, // 1807: forge.Forge.FindTenantsByOrganizationIds:output_type -> forge.TenantList - 543, // 1808: forge.Forge.FindConnectedDevicesByDpuMachineIds:output_type -> forge.ConnectedDeviceList - 547, // 1809: forge.Forge.FindMachineIdsByBmcIps:output_type -> forge.MachineIdBmcIpPairs - 546, // 1810: forge.Forge.FindMacAddressByBmcIp:output_type -> forge.MacAddressBmcIp - 544, // 1811: forge.Forge.FindBmcIps:output_type -> forge.BmcIpList - 520, // 1812: forge.Forge.IdentifyUuid:output_type -> forge.IdentifyUuidResponse - 523, // 1813: forge.Forge.IdentifyMac:output_type -> forge.IdentifyMacResponse - 525, // 1814: forge.Forge.IdentifySerial:output_type -> forge.IdentifySerialResponse - 439, // 1815: forge.Forge.GetBMCMetaData:output_type -> forge.BMCMetaDataGetResponse - 441, // 1816: forge.Forge.UpdateMachineCredentials:output_type -> forge.MachineCredentialsUpdateResponse - 456, // 1817: forge.Forge.GetPxeInstructions:output_type -> forge.PxeInstructions - 460, // 1818: forge.Forge.GetCloudInitInstructions:output_type -> forge.CloudInitInstructions - 153, // 1819: forge.Forge.Echo:output_type -> forge.EchoResponse - 487, // 1820: forge.Forge.CreateTenant:output_type -> forge.CreateTenantResponse - 491, // 1821: forge.Forge.FindTenant:output_type -> forge.FindTenantResponse - 489, // 1822: forge.Forge.UpdateTenant:output_type -> forge.UpdateTenantResponse - 497, // 1823: forge.Forge.CreateTenantKeyset:output_type -> forge.CreateTenantKeysetResponse - 504, // 1824: forge.Forge.FindTenantKeysetIds:output_type -> forge.TenantKeysetIdList - 498, // 1825: forge.Forge.FindTenantKeysetsByIds:output_type -> forge.TenantKeySetList - 500, // 1826: forge.Forge.UpdateTenantKeyset:output_type -> forge.UpdateTenantKeysetResponse - 502, // 1827: forge.Forge.DeleteTenantKeyset:output_type -> forge.DeleteTenantKeysetResponse - 507, // 1828: forge.Forge.ValidateTenantPublicKey:output_type -> forge.ValidateTenantPublicKeyResponse - 381, // 1829: forge.Forge.GetBmcCredentials:output_type -> forge.GetBmcCredentialsResponse - 381, // 1830: forge.Forge.GetSwitchNvosCredentials:output_type -> forge.GetBmcCredentialsResponse - 414, // 1831: forge.Forge.GetAllManagedHostNetworkStatus:output_type -> forge.ManagedHostNetworkStatusResponse - 1163, // 1832: forge.Forge.GetSiteExplorationReport:output_type -> site_explorer.SiteExplorationReport - 1164, // 1833: forge.Forge.GetSiteExplorerLastRun:output_type -> site_explorer.SiteExplorerLastRunResponse - 1091, // 1834: forge.Forge.ClearSiteExplorationError:output_type -> google.protobuf.Empty - 626, // 1835: forge.Forge.IsBmcInManagedHost:output_type -> forge.IsBmcInManagedHostResponse - 627, // 1836: forge.Forge.BmcCredentialStatus:output_type -> forge.BmcCredentialStatusResponse - 1078, // 1837: forge.Forge.Explore:output_type -> site_explorer.EndpointExplorationReport - 1091, // 1838: forge.Forge.ReExploreEndpoint:output_type -> google.protobuf.Empty - 1165, // 1839: forge.Forge.RefreshEndpointReport:output_type -> site_explorer.ExploredEndpoint - 389, // 1840: forge.Forge.DeleteExploredEndpoint:output_type -> forge.DeleteExploredEndpointResponse - 1091, // 1841: forge.Forge.PauseExploredEndpointRemediation:output_type -> google.protobuf.Empty - 1166, // 1842: forge.Forge.FindExploredEndpointIds:output_type -> site_explorer.ExploredEndpointIdList - 1167, // 1843: forge.Forge.FindExploredEndpointsByIds:output_type -> site_explorer.ExploredEndpointList - 1168, // 1844: forge.Forge.FindExploredManagedHostIds:output_type -> site_explorer.ExploredManagedHostIdList - 1169, // 1845: forge.Forge.FindExploredManagedHostsByIds:output_type -> site_explorer.ExploredManagedHostList - 1170, // 1846: forge.Forge.FindExploredMlxDeviceHostIds:output_type -> site_explorer.ExploredMlxDeviceHostIdList - 1171, // 1847: forge.Forge.FindExploredMlxDevicesByIds:output_type -> site_explorer.ExploredMlxDeviceList - 1091, // 1848: forge.Forge.UpdateMachineHardwareInfo:output_type -> google.protobuf.Empty - 420, // 1849: forge.Forge.AdminForceDeleteMachine:output_type -> forge.AdminForceDeleteMachineResponse - 509, // 1850: forge.Forge.AdminListResourcePools:output_type -> forge.ResourcePools - 512, // 1851: forge.Forge.AdminGrowResourcePool:output_type -> forge.GrowResourcePoolResponse - 1091, // 1852: forge.Forge.UpdateMachineMetadata:output_type -> google.protobuf.Empty - 1091, // 1853: forge.Forge.UpdateRackMetadata:output_type -> google.protobuf.Empty - 1091, // 1854: forge.Forge.UpdateSwitchMetadata:output_type -> google.protobuf.Empty - 1091, // 1855: forge.Forge.UpdatePowerShelfMetadata:output_type -> google.protobuf.Empty - 1091, // 1856: forge.Forge.UpdateMachineNvLinkInfo:output_type -> google.protobuf.Empty - 1091, // 1857: forge.Forge.SetMaintenance:output_type -> google.protobuf.Empty - 1091, // 1858: forge.Forge.SetDynamicConfig:output_type -> google.protobuf.Empty - 1091, // 1859: forge.Forge.TriggerDpuReprovisioning:output_type -> google.protobuf.Empty - 528, // 1860: forge.Forge.ListDpuWaitingForReprovisioning:output_type -> forge.DpuReprovisioningListResponse - 1091, // 1861: forge.Forge.TriggerHostReprovisioning:output_type -> google.protobuf.Empty - 533, // 1862: forge.Forge.ListHostsWaitingForReprovisioning:output_type -> forge.HostReprovisioningListResponse - 1091, // 1863: forge.Forge.TriggerBmcCredentialRotation:output_type -> google.protobuf.Empty - 1091, // 1864: forge.Forge.TriggerUefiCredentialRotation:output_type -> google.protobuf.Empty - 1091, // 1865: forge.Forge.MarkManualFirmwareUpgradeComplete:output_type -> google.protobuf.Empty - 1091, // 1866: forge.Forge.ReportScoutFirmwareUpgradeStatus:output_type -> google.protobuf.Empty - 539, // 1867: forge.Forge.GetDpuInfoList:output_type -> forge.GetDpuInfoListResponse - 541, // 1868: forge.Forge.GetMachineBootOverride:output_type -> forge.MachineBootOverride - 1091, // 1869: forge.Forge.SetMachineBootOverride:output_type -> google.protobuf.Empty - 1091, // 1870: forge.Forge.ClearMachineBootOverride:output_type -> google.protobuf.Empty - 965, // 1871: forge.Forge.GetMachineBootInterfaces:output_type -> forge.GetMachineBootInterfacesResponse - 552, // 1872: forge.Forge.GetNetworkTopology:output_type -> forge.NetworkTopologyData - 552, // 1873: forge.Forge.FindNetworkDevicesByDeviceIds:output_type -> forge.NetworkTopologyData - 142, // 1874: forge.Forge.CreateCredential:output_type -> forge.CredentialCreationResult - 143, // 1875: forge.Forge.DeleteCredential:output_type -> forge.CredentialDeletionResult - 145, // 1876: forge.Forge.RotateCredential:output_type -> forge.RotateCredentialResult - 148, // 1877: forge.Forge.GetCredentialRotationStatus:output_type -> forge.CredentialRotationStatusResult - 967, // 1878: forge.Forge.GetContainerRegistryCredential:output_type -> forge.GetContainerRegistryCredentialResponse - 1091, // 1879: forge.Forge.SetContainerRegistryCredential:output_type -> google.protobuf.Empty - 554, // 1880: forge.Forge.GetRouteServers:output_type -> forge.RouteServerEntries - 1091, // 1881: forge.Forge.AddRouteServers:output_type -> google.protobuf.Empty - 1091, // 1882: forge.Forge.RemoveRouteServers:output_type -> google.protobuf.Empty - 1091, // 1883: forge.Forge.ReplaceRouteServers:output_type -> google.protobuf.Empty - 1091, // 1884: forge.Forge.UpdateAgentReportedInventory:output_type -> google.protobuf.Empty - 319, // 1885: forge.Forge.UpdateInstancePhoneHomeLastContact:output_type -> forge.InstancePhoneHomeLastContactResponse - 557, // 1886: forge.Forge.SetHostUefiPassword:output_type -> forge.SetHostUefiPasswordResponse - 559, // 1887: forge.Forge.ClearHostUefiPassword:output_type -> forge.ClearHostUefiPasswordResponse - 1091, // 1888: forge.Forge.AddExpectedMachine:output_type -> google.protobuf.Empty - 1091, // 1889: forge.Forge.DeleteExpectedMachine:output_type -> google.protobuf.Empty - 1091, // 1890: forge.Forge.UpdateExpectedMachine:output_type -> google.protobuf.Empty - 571, // 1891: forge.Forge.GetExpectedMachine:output_type -> forge.ExpectedMachine - 573, // 1892: forge.Forge.GetAllExpectedMachines:output_type -> forge.ExpectedMachineList - 1091, // 1893: forge.Forge.ReplaceAllExpectedMachines:output_type -> google.protobuf.Empty - 1091, // 1894: forge.Forge.DeleteAllExpectedMachines:output_type -> google.protobuf.Empty - 574, // 1895: forge.Forge.GetAllExpectedMachinesLinked:output_type -> forge.LinkedExpectedMachineList - 576, // 1896: forge.Forge.GetAllUnexpectedMachines:output_type -> forge.UnexpectedMachineList - 580, // 1897: forge.Forge.CreateExpectedMachines:output_type -> forge.BatchExpectedMachineOperationResponse - 580, // 1898: forge.Forge.UpdateExpectedMachines:output_type -> forge.BatchExpectedMachineOperationResponse - 1091, // 1899: forge.Forge.AddExpectedPowerShelf:output_type -> google.protobuf.Empty - 1091, // 1900: forge.Forge.DeleteExpectedPowerShelf:output_type -> google.protobuf.Empty - 1091, // 1901: forge.Forge.UpdateExpectedPowerShelf:output_type -> google.protobuf.Empty - 222, // 1902: forge.Forge.GetExpectedPowerShelf:output_type -> forge.ExpectedPowerShelf - 224, // 1903: forge.Forge.GetAllExpectedPowerShelves:output_type -> forge.ExpectedPowerShelfList - 1091, // 1904: forge.Forge.ReplaceAllExpectedPowerShelves:output_type -> google.protobuf.Empty - 1091, // 1905: forge.Forge.DeleteAllExpectedPowerShelves:output_type -> google.protobuf.Empty - 225, // 1906: forge.Forge.GetAllExpectedPowerShelvesLinked:output_type -> forge.LinkedExpectedPowerShelfList - 1091, // 1907: forge.Forge.AddExpectedSwitch:output_type -> google.protobuf.Empty - 1091, // 1908: forge.Forge.DeleteExpectedSwitch:output_type -> google.protobuf.Empty - 1091, // 1909: forge.Forge.UpdateExpectedSwitch:output_type -> google.protobuf.Empty - 244, // 1910: forge.Forge.GetExpectedSwitch:output_type -> forge.ExpectedSwitch - 246, // 1911: forge.Forge.GetAllExpectedSwitches:output_type -> forge.ExpectedSwitchList - 1091, // 1912: forge.Forge.ReplaceAllExpectedSwitches:output_type -> google.protobuf.Empty - 1091, // 1913: forge.Forge.DeleteAllExpectedSwitches:output_type -> google.protobuf.Empty - 247, // 1914: forge.Forge.GetAllExpectedSwitchesLinked:output_type -> forge.LinkedExpectedSwitchList - 1091, // 1915: forge.Forge.AddExpectedRack:output_type -> google.protobuf.Empty - 1091, // 1916: forge.Forge.DeleteExpectedRack:output_type -> google.protobuf.Empty - 1091, // 1917: forge.Forge.UpdateExpectedRack:output_type -> google.protobuf.Empty - 249, // 1918: forge.Forge.GetExpectedRack:output_type -> forge.ExpectedRack - 251, // 1919: forge.Forge.GetAllExpectedRacks:output_type -> forge.ExpectedRackList - 1091, // 1920: forge.Forge.ReplaceAllExpectedRacks:output_type -> google.protobuf.Empty - 1091, // 1921: forge.Forge.DeleteAllExpectedRacks:output_type -> google.protobuf.Empty - 139, // 1922: forge.Forge.AttestQuote:output_type -> forge.AttestQuoteResponse - 654, // 1923: forge.Forge.CreateInstanceType:output_type -> forge.CreateInstanceTypeResponse - 656, // 1924: forge.Forge.FindInstanceTypeIds:output_type -> forge.FindInstanceTypeIdsResponse - 658, // 1925: forge.Forge.FindInstanceTypesByIds:output_type -> forge.FindInstanceTypesByIdsResponse - 661, // 1926: forge.Forge.UpdateInstanceType:output_type -> forge.UpdateInstanceTypeResponse - 660, // 1927: forge.Forge.DeleteInstanceType:output_type -> forge.DeleteInstanceTypeResponse - 664, // 1928: forge.Forge.AssociateMachinesWithInstanceType:output_type -> forge.AssociateMachinesWithInstanceTypeResponse - 666, // 1929: forge.Forge.RemoveMachineInstanceTypeAssociation:output_type -> forge.RemoveMachineInstanceTypeAssociationResponse - 1172, // 1930: forge.Forge.CreateMeasurementBundle:output_type -> measured_boot.CreateMeasurementBundleResponse - 1173, // 1931: forge.Forge.DeleteMeasurementBundle:output_type -> measured_boot.DeleteMeasurementBundleResponse - 1174, // 1932: forge.Forge.RenameMeasurementBundle:output_type -> measured_boot.RenameMeasurementBundleResponse - 1175, // 1933: forge.Forge.UpdateMeasurementBundle:output_type -> measured_boot.UpdateMeasurementBundleResponse - 1176, // 1934: forge.Forge.ShowMeasurementBundle:output_type -> measured_boot.ShowMeasurementBundleResponse - 1177, // 1935: forge.Forge.ShowMeasurementBundles:output_type -> measured_boot.ShowMeasurementBundlesResponse - 1178, // 1936: forge.Forge.ListMeasurementBundles:output_type -> measured_boot.ListMeasurementBundlesResponse - 1179, // 1937: forge.Forge.ListMeasurementBundleMachines:output_type -> measured_boot.ListMeasurementBundleMachinesResponse - 1176, // 1938: forge.Forge.FindClosestBundleMatch:output_type -> measured_boot.ShowMeasurementBundleResponse - 1180, // 1939: forge.Forge.DeleteMeasurementJournal:output_type -> measured_boot.DeleteMeasurementJournalResponse - 1181, // 1940: forge.Forge.ShowMeasurementJournal:output_type -> measured_boot.ShowMeasurementJournalResponse - 1182, // 1941: forge.Forge.ShowMeasurementJournals:output_type -> measured_boot.ShowMeasurementJournalsResponse - 1183, // 1942: forge.Forge.ListMeasurementJournal:output_type -> measured_boot.ListMeasurementJournalResponse - 1184, // 1943: forge.Forge.AttestCandidateMachine:output_type -> measured_boot.AttestCandidateMachineResponse - 1185, // 1944: forge.Forge.ShowCandidateMachine:output_type -> measured_boot.ShowCandidateMachineResponse - 1186, // 1945: forge.Forge.ShowCandidateMachines:output_type -> measured_boot.ShowCandidateMachinesResponse - 1187, // 1946: forge.Forge.ListCandidateMachines:output_type -> measured_boot.ListCandidateMachinesResponse - 1188, // 1947: forge.Forge.CreateMeasurementSystemProfile:output_type -> measured_boot.CreateMeasurementSystemProfileResponse - 1189, // 1948: forge.Forge.DeleteMeasurementSystemProfile:output_type -> measured_boot.DeleteMeasurementSystemProfileResponse - 1190, // 1949: forge.Forge.RenameMeasurementSystemProfile:output_type -> measured_boot.RenameMeasurementSystemProfileResponse - 1191, // 1950: forge.Forge.ShowMeasurementSystemProfile:output_type -> measured_boot.ShowMeasurementSystemProfileResponse - 1192, // 1951: forge.Forge.ShowMeasurementSystemProfiles:output_type -> measured_boot.ShowMeasurementSystemProfilesResponse - 1193, // 1952: forge.Forge.ListMeasurementSystemProfiles:output_type -> measured_boot.ListMeasurementSystemProfilesResponse - 1194, // 1953: forge.Forge.ListMeasurementSystemProfileBundles:output_type -> measured_boot.ListMeasurementSystemProfileBundlesResponse - 1195, // 1954: forge.Forge.ListMeasurementSystemProfileMachines:output_type -> measured_boot.ListMeasurementSystemProfileMachinesResponse - 1196, // 1955: forge.Forge.CreateMeasurementReport:output_type -> measured_boot.CreateMeasurementReportResponse - 1197, // 1956: forge.Forge.DeleteMeasurementReport:output_type -> measured_boot.DeleteMeasurementReportResponse - 1198, // 1957: forge.Forge.PromoteMeasurementReport:output_type -> measured_boot.PromoteMeasurementReportResponse - 1199, // 1958: forge.Forge.RevokeMeasurementReport:output_type -> measured_boot.RevokeMeasurementReportResponse - 1200, // 1959: forge.Forge.ShowMeasurementReportForId:output_type -> measured_boot.ShowMeasurementReportForIdResponse - 1201, // 1960: forge.Forge.ShowMeasurementReportsForMachine:output_type -> measured_boot.ShowMeasurementReportsForMachineResponse - 1202, // 1961: forge.Forge.ShowMeasurementReports:output_type -> measured_boot.ShowMeasurementReportsResponse - 1203, // 1962: forge.Forge.ListMeasurementReport:output_type -> measured_boot.ListMeasurementReportResponse - 1204, // 1963: forge.Forge.MatchMeasurementReport:output_type -> measured_boot.MatchMeasurementReportResponse - 1205, // 1964: forge.Forge.ImportSiteMeasurements:output_type -> measured_boot.ImportSiteMeasurementsResponse - 1206, // 1965: forge.Forge.ExportSiteMeasurements:output_type -> measured_boot.ExportSiteMeasurementsResponse - 1207, // 1966: forge.Forge.AddMeasurementTrustedMachine:output_type -> measured_boot.AddMeasurementTrustedMachineResponse - 1208, // 1967: forge.Forge.RemoveMeasurementTrustedMachine:output_type -> measured_boot.RemoveMeasurementTrustedMachineResponse - 1209, // 1968: forge.Forge.AddMeasurementTrustedProfile:output_type -> measured_boot.AddMeasurementTrustedProfileResponse - 1210, // 1969: forge.Forge.RemoveMeasurementTrustedProfile:output_type -> measured_boot.RemoveMeasurementTrustedProfileResponse - 1211, // 1970: forge.Forge.ListMeasurementTrustedMachines:output_type -> measured_boot.ListMeasurementTrustedMachinesResponse - 1212, // 1971: forge.Forge.ListMeasurementTrustedProfiles:output_type -> measured_boot.ListMeasurementTrustedProfilesResponse - 1213, // 1972: forge.Forge.ListAttestationSummary:output_type -> measured_boot.ListAttestationSummaryResponse - 685, // 1973: forge.Forge.CreateNetworkSecurityGroup:output_type -> forge.CreateNetworkSecurityGroupResponse - 687, // 1974: forge.Forge.FindNetworkSecurityGroupIds:output_type -> forge.FindNetworkSecurityGroupIdsResponse - 689, // 1975: forge.Forge.FindNetworkSecurityGroupsByIds:output_type -> forge.FindNetworkSecurityGroupsByIdsResponse - 690, // 1976: forge.Forge.UpdateNetworkSecurityGroup:output_type -> forge.UpdateNetworkSecurityGroupResponse - 693, // 1977: forge.Forge.DeleteNetworkSecurityGroup:output_type -> forge.DeleteNetworkSecurityGroupResponse - 696, // 1978: forge.Forge.GetNetworkSecurityGroupPropagationStatus:output_type -> forge.GetNetworkSecurityGroupPropagationStatusResponse - 703, // 1979: forge.Forge.GetNetworkSecurityGroupAttachments:output_type -> forge.GetNetworkSecurityGroupAttachmentsResponse - 561, // 1980: forge.Forge.CreateOsImage:output_type -> forge.OsImage - 565, // 1981: forge.Forge.DeleteOsImage:output_type -> forge.DeleteOsImageResponse - 563, // 1982: forge.Forge.ListOsImage:output_type -> forge.ListOsImageResponse - 561, // 1983: forge.Forge.GetOsImage:output_type -> forge.OsImage - 561, // 1984: forge.Forge.UpdateOsImage:output_type -> forge.OsImage - 282, // 1985: forge.Forge.GetIpxeTemplate:output_type -> forge.IpxeTemplate - 568, // 1986: forge.Forge.ListIpxeTemplates:output_type -> forge.IpxeTemplateList - 581, // 1987: forge.Forge.RebootCompleted:output_type -> forge.MachineRebootCompletedResponse - 1091, // 1988: forge.Forge.PersistValidationResult:output_type -> google.protobuf.Empty - 588, // 1989: forge.Forge.GetMachineValidationResults:output_type -> forge.MachineValidationResultList - 585, // 1990: forge.Forge.MachineValidationCompleted:output_type -> forge.MachineValidationCompletedResponse - 593, // 1991: forge.Forge.MachineSetAutoUpdate:output_type -> forge.MachineSetAutoUpdateResponse - 596, // 1992: forge.Forge.GetMachineValidationExternalConfig:output_type -> forge.GetMachineValidationExternalConfigResponse - 598, // 1993: forge.Forge.GetMachineValidationExternalConfigs:output_type -> forge.GetMachineValidationExternalConfigsResponse - 1091, // 1994: forge.Forge.AddUpdateMachineValidationExternalConfig:output_type -> google.protobuf.Empty - 615, // 1995: forge.Forge.GetMachineValidationRuns:output_type -> forge.MachineValidationRunList - 618, // 1996: forge.Forge.FindMachineValidationRunItemIds:output_type -> forge.MachineValidationRunItemIdList - 620, // 1997: forge.Forge.FindMachineValidationRunItemsByIds:output_type -> forge.MachineValidationRunItemList - 623, // 1998: forge.Forge.GetMachineValidationAttempt:output_type -> forge.MachineValidationAttempt - 625, // 1999: forge.Forge.HeartbeatMachineValidationRun:output_type -> forge.MachineValidationHeartbeatResponse - 1091, // 2000: forge.Forge.RemoveMachineValidationExternalConfig:output_type -> google.protobuf.Empty - 632, // 2001: forge.Forge.GetMachineValidationTests:output_type -> forge.MachineValidationTestsGetResponse - 631, // 2002: forge.Forge.AddMachineValidationTest:output_type -> forge.MachineValidationTestAddUpdateResponse - 631, // 2003: forge.Forge.UpdateMachineValidationTest:output_type -> forge.MachineValidationTestAddUpdateResponse - 634, // 2004: forge.Forge.MachineValidationTestVerfied:output_type -> forge.MachineValidationTestVerfiedResponse - 636, // 2005: forge.Forge.MachineValidationTestNextVersion:output_type -> forge.MachineValidationTestNextVersionResponse - 639, // 2006: forge.Forge.MachineValidationTestEnableDisableTest:output_type -> forge.MachineValidationTestEnableDisableTestResponse - 641, // 2007: forge.Forge.UpdateMachineValidationRun:output_type -> forge.MachineValidationRunResponse - 433, // 2008: forge.Forge.AdminBmcReset:output_type -> forge.AdminBmcResetResponse - 612, // 2009: forge.Forge.AdminPowerControl:output_type -> forge.AdminPowerControlResponse - 421, // 2010: forge.Forge.DisableSecureBoot:output_type -> forge.DisableSecureBootResponse - 423, // 2011: forge.Forge.Lockdown:output_type -> forge.LockdownResponse - 1214, // 2012: forge.Forge.LockdownStatus:output_type -> site_explorer.LockdownStatus - 427, // 2013: forge.Forge.MachineSetup:output_type -> forge.MachineSetupResponse - 429, // 2014: forge.Forge.SetDpuFirstBootOrder:output_type -> forge.SetDpuFirstBootOrderResponse - 808, // 2015: forge.Forge.CreateBmcUser:output_type -> forge.CreateBmcUserResponse - 810, // 2016: forge.Forge.DeleteBmcUser:output_type -> forge.DeleteBmcUserResponse - 812, // 2017: forge.Forge.SetBmcRootPassword:output_type -> forge.SetBmcRootPasswordResponse - 814, // 2018: forge.Forge.ProbeBmcVendor:output_type -> forge.ProbeBmcVendorResponse - 435, // 2019: forge.Forge.EnableInfiniteBoot:output_type -> forge.EnableInfiniteBootResponse - 437, // 2020: forge.Forge.IsInfiniteBootEnabled:output_type -> forge.IsInfiniteBootEnabledResponse - 602, // 2021: forge.Forge.OnDemandMachineValidation:output_type -> forge.MachineValidationOnDemandResponse - 610, // 2022: forge.Forge.OnDemandRackMaintenance:output_type -> forge.RackMaintenanceOnDemandResponse - 130, // 2023: forge.Forge.TpmAddCaCert:output_type -> forge.TpmCaAddedCaStatus - 136, // 2024: forge.Forge.TpmShowCaCerts:output_type -> forge.TpmCaCertDetailCollection - 133, // 2025: forge.Forge.TpmShowUnmatchedEkCerts:output_type -> forge.TpmEkCertStatusCollection - 1091, // 2026: forge.Forge.TpmDeleteCaCert:output_type -> google.protobuf.Empty - 668, // 2027: forge.Forge.RedfishBrowse:output_type -> forge.RedfishBrowseResponse - 670, // 2028: forge.Forge.RedfishListActions:output_type -> forge.RedfishListActionsResponse - 675, // 2029: forge.Forge.RedfishCreateAction:output_type -> forge.RedfishCreateActionResponse - 677, // 2030: forge.Forge.RedfishApproveAction:output_type -> forge.RedfishApproveActionResponse - 678, // 2031: forge.Forge.RedfishApplyAction:output_type -> forge.RedfishApplyActionResponse - 679, // 2032: forge.Forge.RedfishCancelAction:output_type -> forge.RedfishCancelActionResponse - 681, // 2033: forge.Forge.UfmBrowse:output_type -> forge.UfmBrowseResponse - 705, // 2034: forge.Forge.GetDesiredFirmwareVersions:output_type -> forge.GetDesiredFirmwareVersionsResponse - 823, // 2035: forge.Forge.UpsertHostFirmwareConfig:output_type -> forge.HostFirmwareConfigResponse - 1091, // 2036: forge.Forge.DeleteHostFirmwareConfig:output_type -> google.protobuf.Empty - 721, // 2037: forge.Forge.CreateSku:output_type -> forge.SkuIdList - 717, // 2038: forge.Forge.GenerateSkuFromMachine:output_type -> forge.Sku - 1091, // 2039: forge.Forge.VerifySkuForMachine:output_type -> google.protobuf.Empty - 1091, // 2040: forge.Forge.AssignSkuToMachine:output_type -> google.protobuf.Empty - 1091, // 2041: forge.Forge.RemoveSkuAssociation:output_type -> google.protobuf.Empty - 1091, // 2042: forge.Forge.DeleteSku:output_type -> google.protobuf.Empty - 721, // 2043: forge.Forge.GetAllSkuIds:output_type -> forge.SkuIdList - 720, // 2044: forge.Forge.FindSkusByIds:output_type -> forge.SkuList - 1091, // 2045: forge.Forge.UpdateSkuMetadata:output_type -> google.protobuf.Empty - 717, // 2046: forge.Forge.ReplaceSku:output_type -> forge.Sku - 403, // 2047: forge.Forge.GetManagedHostQuarantineState:output_type -> forge.GetManagedHostQuarantineStateResponse - 405, // 2048: forge.Forge.SetManagedHostQuarantineState:output_type -> forge.SetManagedHostQuarantineStateResponse - 407, // 2049: forge.Forge.ClearManagedHostQuarantineState:output_type -> forge.ClearManagedHostQuarantineStateResponse - 1091, // 2050: forge.Forge.ResetHostReprovisioning:output_type -> google.protobuf.Empty - 1091, // 2051: forge.Forge.CopyBfbToDpuRshim:output_type -> google.protobuf.Empty - 727, // 2052: forge.Forge.GetAllDpaInterfaceIds:output_type -> forge.DpaInterfaceIdList - 729, // 2053: forge.Forge.FindDpaInterfacesByIds:output_type -> forge.DpaInterfaceList - 725, // 2054: forge.Forge.CreateDpaInterface:output_type -> forge.DpaInterface - 725, // 2055: forge.Forge.EnsureDpaInterface:output_type -> forge.DpaInterface - 732, // 2056: forge.Forge.DeleteDpaInterface:output_type -> forge.DpaInterfaceDeletionResult - 737, // 2057: forge.Forge.GetPowerOptions:output_type -> forge.PowerOptionResponse - 737, // 2058: forge.Forge.UpdatePowerOption:output_type -> forge.PowerOptionResponse - 1091, // 2059: forge.Forge.AllowIngestionAndPowerOn:output_type -> google.protobuf.Empty - 129, // 2060: forge.Forge.DetermineMachineIngestionState:output_type -> forge.MachineIngestionStateResponse - 755, // 2061: forge.Forge.FindRackIds:output_type -> forge.RackIdList - 753, // 2062: forge.Forge.FindRacksByIds:output_type -> forge.RackList - 752, // 2063: forge.Forge.GetRack:output_type -> forge.GetRackResponse - 1091, // 2064: forge.Forge.DeleteRack:output_type -> google.protobuf.Empty - 763, // 2065: forge.Forge.AdminForceDeleteRack:output_type -> forge.AdminForceDeleteRackResponse - 770, // 2066: forge.Forge.GetRackProfile:output_type -> forge.GetRackProfileResponse - 741, // 2067: forge.Forge.CreateComputeAllocation:output_type -> forge.CreateComputeAllocationResponse - 743, // 2068: forge.Forge.FindComputeAllocationIds:output_type -> forge.FindComputeAllocationIdsResponse - 745, // 2069: forge.Forge.FindComputeAllocationsByIds:output_type -> forge.FindComputeAllocationsByIdsResponse - 746, // 2070: forge.Forge.UpdateComputeAllocation:output_type -> forge.UpdateComputeAllocationResponse - 749, // 2071: forge.Forge.DeleteComputeAllocation:output_type -> forge.DeleteComputeAllocationResponse - 816, // 2072: forge.Forge.SetFirmwareUpdateTimeWindow:output_type -> forge.SetFirmwareUpdateTimeWindowResponse - 825, // 2073: forge.Forge.ListHostFirmware:output_type -> forge.ListHostFirmwareResponse - 1215, // 2074: forge.Forge.PublishMlxDeviceReport:output_type -> mlx_device.PublishMlxDeviceReportResponse - 1216, // 2075: forge.Forge.PublishMlxObservationReport:output_type -> mlx_device.PublishMlxObservationReportResponse - 828, // 2076: forge.Forge.TrimTable:output_type -> forge.TrimTableResponse - 830, // 2077: forge.Forge.ListNvlinkNmxcEndpoints:output_type -> forge.NvlinkNmxcEndpointList - 829, // 2078: forge.Forge.CreateNvlinkNmxcEndpoint:output_type -> forge.NvlinkNmxcEndpoint - 829, // 2079: forge.Forge.UpdateNvlinkNmxcEndpoint:output_type -> forge.NvlinkNmxcEndpoint - 1091, // 2080: forge.Forge.DeleteNvlinkNmxcEndpoint:output_type -> google.protobuf.Empty - 833, // 2081: forge.Forge.CreateRemediation:output_type -> forge.CreateRemediationResponse - 1091, // 2082: forge.Forge.ApproveRemediation:output_type -> google.protobuf.Empty - 1091, // 2083: forge.Forge.RevokeRemediation:output_type -> google.protobuf.Empty - 1091, // 2084: forge.Forge.EnableRemediation:output_type -> google.protobuf.Empty - 1091, // 2085: forge.Forge.DisableRemediation:output_type -> google.protobuf.Empty - 834, // 2086: forge.Forge.FindRemediationIds:output_type -> forge.RemediationIdList - 835, // 2087: forge.Forge.FindRemediationsByIds:output_type -> forge.RemediationList - 842, // 2088: forge.Forge.FindAppliedRemediationIds:output_type -> forge.AppliedRemediationIdList - 845, // 2089: forge.Forge.FindAppliedRemediations:output_type -> forge.AppliedRemediationList - 847, // 2090: forge.Forge.GetNextRemediationForMachine:output_type -> forge.GetNextRemediationForMachineResponse - 1091, // 2091: forge.Forge.RemediationApplied:output_type -> google.protobuf.Empty - 1091, // 2092: forge.Forge.SetPrimaryDpu:output_type -> google.protobuf.Empty - 1091, // 2093: forge.Forge.SetPrimaryInterface:output_type -> google.protobuf.Empty - 856, // 2094: forge.Forge.CreateDpuExtensionService:output_type -> forge.DpuExtensionService - 856, // 2095: forge.Forge.UpdateDpuExtensionService:output_type -> forge.DpuExtensionService - 860, // 2096: forge.Forge.DeleteDpuExtensionService:output_type -> forge.DeleteDpuExtensionServiceResponse - 862, // 2097: forge.Forge.FindDpuExtensionServiceIds:output_type -> forge.DpuExtensionServiceIdList - 864, // 2098: forge.Forge.FindDpuExtensionServicesByIds:output_type -> forge.DpuExtensionServiceList - 866, // 2099: forge.Forge.GetDpuExtensionServiceVersionsInfo:output_type -> forge.DpuExtensionServiceVersionInfoList - 868, // 2100: forge.Forge.FindInstancesByDpuExtensionService:output_type -> forge.FindInstancesByDpuExtensionServiceResponse - 103, // 2101: forge.Forge.TriggerMachineAttestation:output_type -> forge.SpdmMachineAttestationTriggerResponse - 1091, // 2102: forge.Forge.CancelMachineAttestation:output_type -> google.protobuf.Empty - 108, // 2103: forge.Forge.ListAttestationMachines:output_type -> forge.SpdmListAttestationMachinesResponse - 105, // 2104: forge.Forge.GetAttestationMachine:output_type -> forge.SpdmGetAttestationMachineResponse - 110, // 2105: forge.Forge.SignMachineIdentity:output_type -> forge.MachineIdentityResponse - 115, // 2106: forge.Forge.GetTenantIdentityConfiguration:output_type -> forge.TenantIdentityConfigResponse - 115, // 2107: forge.Forge.SetTenantIdentityConfiguration:output_type -> forge.TenantIdentityConfigResponse - 1091, // 2108: forge.Forge.DeleteTenantIdentityConfiguration:output_type -> google.protobuf.Empty - 118, // 2109: forge.Forge.GetTokenDelegation:output_type -> forge.TokenDelegationResponse - 118, // 2110: forge.Forge.SetTokenDelegation:output_type -> forge.TokenDelegationResponse - 1091, // 2111: forge.Forge.DeleteTokenDelegation:output_type -> google.protobuf.Empty - 124, // 2112: forge.Forge.ReencryptTenantIdentitySecrets:output_type -> forge.ReencryptTenantIdentitySecretsResponse - 125, // 2113: forge.Forge.GetJWKS:output_type -> forge.Jwks - 126, // 2114: forge.Forge.GetOpenIDConfiguration:output_type -> forge.OpenIdConfiguration - 875, // 2115: forge.Forge.ScoutStream:output_type -> forge.ScoutStreamScoutBoundMessage - 878, // 2116: forge.Forge.ScoutStreamShowConnections:output_type -> forge.ScoutStreamShowConnectionsResponse - 880, // 2117: forge.Forge.ScoutStreamDisconnect:output_type -> forge.ScoutStreamDisconnectResponse - 882, // 2118: forge.Forge.ScoutStreamPing:output_type -> forge.ScoutStreamAdminPingResponse - 1217, // 2119: forge.Forge.MlxAdminProfileSync:output_type -> mlx_device.MlxAdminProfileSyncResponse - 1218, // 2120: forge.Forge.MlxAdminProfileShow:output_type -> mlx_device.MlxAdminProfileShowResponse - 1219, // 2121: forge.Forge.MlxAdminProfileCompare:output_type -> mlx_device.MlxAdminProfileCompareResponse - 1220, // 2122: forge.Forge.MlxAdminProfileList:output_type -> mlx_device.MlxAdminProfileListResponse - 1221, // 2123: forge.Forge.MlxAdminLockdownLock:output_type -> mlx_device.MlxAdminLockdownLockResponse - 1222, // 2124: forge.Forge.MlxAdminLockdownUnlock:output_type -> mlx_device.MlxAdminLockdownUnlockResponse - 1223, // 2125: forge.Forge.MlxAdminLockdownStatus:output_type -> mlx_device.MlxAdminLockdownStatusResponse - 1224, // 2126: forge.Forge.MlxAdminShowDevice:output_type -> mlx_device.MlxAdminDeviceInfoResponse - 1225, // 2127: forge.Forge.MlxAdminShowMachine:output_type -> mlx_device.MlxAdminDeviceReportResponse - 1226, // 2128: forge.Forge.MlxAdminRegistryList:output_type -> mlx_device.MlxAdminRegistryListResponse - 1227, // 2129: forge.Forge.MlxAdminRegistryShow:output_type -> mlx_device.MlxAdminRegistryShowResponse - 1228, // 2130: forge.Forge.MlxAdminConfigQuery:output_type -> mlx_device.MlxAdminConfigQueryResponse - 1229, // 2131: forge.Forge.MlxAdminConfigSet:output_type -> mlx_device.MlxAdminConfigSetResponse - 1230, // 2132: forge.Forge.MlxAdminConfigSync:output_type -> mlx_device.MlxAdminConfigSyncResponse - 1231, // 2133: forge.Forge.MlxAdminConfigCompare:output_type -> mlx_device.MlxAdminConfigCompareResponse - 793, // 2134: forge.Forge.FindNVLinkPartitionIds:output_type -> forge.NVLinkPartitionIdList - 788, // 2135: forge.Forge.FindNVLinkPartitionsByIds:output_type -> forge.NVLinkPartitionList - 788, // 2136: forge.Forge.NVLinkPartitionsForTenant:output_type -> forge.NVLinkPartitionList - 804, // 2137: forge.Forge.FindNVLinkLogicalPartitionIds:output_type -> forge.NVLinkLogicalPartitionIdList - 798, // 2138: forge.Forge.FindNVLinkLogicalPartitionsByIds:output_type -> forge.NVLinkLogicalPartitionList - 797, // 2139: forge.Forge.CreateNVLinkLogicalPartition:output_type -> forge.NVLinkLogicalPartition - 806, // 2140: forge.Forge.UpdateNVLinkLogicalPartition:output_type -> forge.NVLinkLogicalPartitionUpdateResult - 801, // 2141: forge.Forge.DeleteNVLinkLogicalPartition:output_type -> forge.NVLinkLogicalPartitionDeletionResult - 798, // 2142: forge.Forge.NVLinkLogicalPartitionsForTenant:output_type -> forge.NVLinkLogicalPartitionList - 896, // 2143: forge.Forge.GetMachinePositionInfo:output_type -> forge.MachinePositionInfoList - 786, // 2144: forge.Forge.NmxcBrowse:output_type -> forge.NmxcBrowseResponse - 1091, // 2145: forge.Forge.ModifyDPFState:output_type -> google.protobuf.Empty - 899, // 2146: forge.Forge.GetDPFState:output_type -> forge.DPFStateResponse - 902, // 2147: forge.Forge.GetDPFHostSnapshot:output_type -> forge.DPFHostSnapshotResponse - 905, // 2148: forge.Forge.GetDPFServiceVersions:output_type -> forge.DPFServiceVersionsResponse - 913, // 2149: forge.Forge.ComponentPowerControl:output_type -> forge.ComponentPowerControlResponse - 915, // 2150: forge.Forge.ComponentConfigureSwitchCertificate:output_type -> forge.ComponentConfigureSwitchCertificateResponse - 911, // 2151: forge.Forge.GetComponentInventory:output_type -> forge.GetComponentInventoryResponse - 922, // 2152: forge.Forge.UpdateComponentFirmware:output_type -> forge.UpdateComponentFirmwareResponse - 924, // 2153: forge.Forge.GetComponentFirmwareStatus:output_type -> forge.GetComponentFirmwareStatusResponse - 928, // 2154: forge.Forge.ListComponentFirmwareVersions:output_type -> forge.ListComponentFirmwareVersionsResponse - 941, // 2155: forge.Forge.CreateOperatingSystem:output_type -> forge.OperatingSystem - 941, // 2156: forge.Forge.GetOperatingSystem:output_type -> forge.OperatingSystem - 941, // 2157: forge.Forge.UpdateOperatingSystem:output_type -> forge.OperatingSystem - 947, // 2158: forge.Forge.DeleteOperatingSystem:output_type -> forge.DeleteOperatingSystemResponse - 949, // 2159: forge.Forge.FindOperatingSystemIds:output_type -> forge.OperatingSystemIdList - 951, // 2160: forge.Forge.FindOperatingSystemsByIds:output_type -> forge.OperatingSystemList - 953, // 2161: forge.Forge.GetOperatingSystemCachableIpxeTemplateArtifacts:output_type -> forge.IpxeTemplateArtifactList - 953, // 2162: forge.Forge.UpdateOperatingSystemCachableIpxeTemplateArtifacts:output_type -> forge.IpxeTemplateArtifactList - 958, // 2163: forge.Forge.ReWrapSecrets:output_type -> forge.ReWrapSecretsResponse - 1695, // [1695:2164] is the sub-list for method output_type - 1226, // [1226:1695] is the sub-list for method input_type - 1226, // [1226:1226] is the sub-list for extension type_name - 1226, // [1226:1226] is the sub-list for extension extendee - 0, // [0:1226] is the sub-list for field type_name + 1018, // 678: forge.SetHostUefiPasswordRequest.host_id:type_name -> common.MachineId + 1018, // 679: forge.ClearHostUefiPasswordRequest.host_id:type_name -> common.MachineId + 1018, // 680: forge.SetDpuUefiPasswordRequest.dpu_id:type_name -> common.MachineId + 1030, // 681: forge.OsImageAttributes.id:type_name -> common.UUID + 562, // 682: forge.OsImage.attributes:type_name -> forge.OsImageAttributes + 50, // 683: forge.OsImage.status:type_name -> forge.OsImageStatus + 563, // 684: forge.ListOsImageResponse.images:type_name -> forge.OsImage + 1030, // 685: forge.DeleteOsImageRequest.id:type_name -> common.UUID + 1037, // 686: forge.GetIpxeTemplateRequest.id:type_name -> common.IpxeTemplateId + 282, // 687: forge.IpxeTemplateList.templates:type_name -> forge.IpxeTemplate + 12, // 688: forge.ExpectedHostNic.network_segment_type:type_name -> forge.NetworkSegmentType + 82, // 689: forge.ExpectedHostNic.role:type_name -> forge.ExpectedInterfaceRole + 83, // 690: forge.ExpectedHostNic.ip_allocation:type_name -> forge.ExpectedInterfaceIpAllocation + 273, // 691: forge.ExpectedMachine.metadata:type_name -> forge.Metadata + 1030, // 692: forge.ExpectedMachine.id:type_name -> common.UUID + 571, // 693: forge.ExpectedMachine.host_nics:type_name -> forge.ExpectedHostNic + 1029, // 694: forge.ExpectedMachine.rack_id:type_name -> common.RackId + 51, // 695: forge.ExpectedMachine.dpu_mode:type_name -> forge.DpuMode + 572, // 696: forge.ExpectedMachine.host_lifecycle_profile:type_name -> forge.HostLifecycleProfile + 52, // 697: forge.ExpectedMachine.bmc_ip_allocation:type_name -> forge.BmcIpAllocationType + 1030, // 698: forge.ExpectedMachineRequest.id:type_name -> common.UUID + 573, // 699: forge.ExpectedMachineList.expected_machines:type_name -> forge.ExpectedMachine + 577, // 700: forge.LinkedExpectedMachineList.expected_machines:type_name -> forge.LinkedExpectedMachine + 1018, // 701: forge.LinkedExpectedMachine.machine_id:type_name -> common.MachineId + 1030, // 702: forge.LinkedExpectedMachine.expected_machine_id:type_name -> common.UUID + 579, // 703: forge.UnexpectedMachineList.unexpected_machines:type_name -> forge.UnexpectedMachine + 1018, // 704: forge.UnexpectedMachine.machine_id:type_name -> common.MachineId + 575, // 705: forge.BatchExpectedMachineOperationRequest.expected_machines:type_name -> forge.ExpectedMachineList + 1030, // 706: forge.ExpectedMachineOperationResult.id:type_name -> common.UUID + 573, // 707: forge.ExpectedMachineOperationResult.expected_machine:type_name -> forge.ExpectedMachine + 581, // 708: forge.BatchExpectedMachineOperationResponse.results:type_name -> forge.ExpectedMachineOperationResult + 1018, // 709: forge.MachineRebootCompletedRequest.machine_id:type_name -> common.MachineId + 1018, // 710: forge.ScoutFirmwareUpgradeStatusRequest.machine_id:type_name -> common.MachineId + 1018, // 711: forge.MachineValidationCompletedRequest.machine_id:type_name -> common.MachineId + 1047, // 712: forge.MachineValidationCompletedRequest.validation_id:type_name -> common.MachineValidationId + 1019, // 713: forge.MachineValidationResult.start_time:type_name -> google.protobuf.Timestamp + 1019, // 714: forge.MachineValidationResult.end_time:type_name -> google.protobuf.Timestamp + 1047, // 715: forge.MachineValidationResult.validation_id:type_name -> common.MachineValidationId + 588, // 716: forge.MachineValidationResultPostRequest.result:type_name -> forge.MachineValidationResult + 588, // 717: forge.MachineValidationResultList.results:type_name -> forge.MachineValidationResult + 1018, // 718: forge.MachineValidationGetRequest.machine_id:type_name -> common.MachineId + 1047, // 719: forge.MachineValidationGetRequest.validation_id:type_name -> common.MachineValidationId + 53, // 720: forge.MachineValidationStatus.started:type_name -> forge.MachineValidationStarted + 54, // 721: forge.MachineValidationStatus.in_progress:type_name -> forge.MachineValidationInProgress + 55, // 722: forge.MachineValidationStatus.completed:type_name -> forge.MachineValidationCompleted + 1047, // 723: forge.MachineValidationRun.validation_id:type_name -> common.MachineValidationId + 1018, // 724: forge.MachineValidationRun.machine_id:type_name -> common.MachineId + 1019, // 725: forge.MachineValidationRun.start_time:type_name -> google.protobuf.Timestamp + 1019, // 726: forge.MachineValidationRun.end_time:type_name -> google.protobuf.Timestamp + 592, // 727: forge.MachineValidationRun.status:type_name -> forge.MachineValidationStatus + 1043, // 728: forge.MachineValidationRun.duration_to_complete:type_name -> google.protobuf.Duration + 1019, // 729: forge.MachineValidationRun.last_heartbeat_at:type_name -> google.protobuf.Timestamp + 1018, // 730: forge.MachineSetAutoUpdateRequest.machine_id:type_name -> common.MachineId + 96, // 731: forge.MachineSetAutoUpdateRequest.action:type_name -> forge.MachineSetAutoUpdateRequest.SetAutoupdateAction + 1019, // 732: forge.MachineValidationExternalConfig.timestamp:type_name -> google.protobuf.Timestamp + 597, // 733: forge.GetMachineValidationExternalConfigResponse.config:type_name -> forge.MachineValidationExternalConfig + 597, // 734: forge.GetMachineValidationExternalConfigsResponse.configs:type_name -> forge.MachineValidationExternalConfig + 1018, // 735: forge.MachineValidationOnDemandRequest.machine_id:type_name -> common.MachineId + 97, // 736: forge.MachineValidationOnDemandRequest.action:type_name -> forge.MachineValidationOnDemandRequest.Action + 1047, // 737: forge.MachineValidationOnDemandResponse.validation_id:type_name -> common.MachineValidationId + 605, // 738: forge.MaintenanceActivityConfig.firmware_upgrade:type_name -> forge.FirmwareUpgradeActivity + 607, // 739: forge.MaintenanceActivityConfig.configure_nmx_cluster:type_name -> forge.ConfigureNmxClusterActivity + 608, // 740: forge.MaintenanceActivityConfig.power_sequence:type_name -> forge.PowerSequenceActivity + 606, // 741: forge.MaintenanceActivityConfig.nvos_update:type_name -> forge.NvosUpdateActivity + 609, // 742: forge.RackMaintenanceScope.activities:type_name -> forge.MaintenanceActivityConfig + 1029, // 743: forge.RackMaintenanceOnDemandRequest.rack_id:type_name -> common.RackId + 610, // 744: forge.RackMaintenanceOnDemandRequest.scope:type_name -> forge.RackMaintenanceScope + 390, // 745: forge.AdminPowerControlRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest + 98, // 746: forge.AdminPowerControlRequest.action:type_name -> forge.AdminPowerControlRequest.SystemPowerControl + 1018, // 747: forge.GetRedfishJobStateRequest.machine_id:type_name -> common.MachineId + 99, // 748: forge.GetRedfishJobStateResponse.job_state:type_name -> forge.GetRedfishJobStateResponse.RedfishJobState + 593, // 749: forge.MachineValidationRunList.runs:type_name -> forge.MachineValidationRun + 1018, // 750: forge.MachineValidationRunListGetRequest.machine_id:type_name -> common.MachineId + 1047, // 751: forge.MachineValidationRunItemSearchFilter.validation_id:type_name -> common.MachineValidationId + 1030, // 752: forge.MachineValidationRunItemIdList.run_item_ids:type_name -> common.UUID + 1030, // 753: forge.MachineValidationRunItemsByIdsRequest.run_item_ids:type_name -> common.UUID + 623, // 754: forge.MachineValidationRunItemList.run_items:type_name -> forge.MachineValidationRunItem + 1030, // 755: forge.MachineValidationRunItem.run_item_id:type_name -> common.UUID + 1047, // 756: forge.MachineValidationRunItem.validation_id:type_name -> common.MachineValidationId + 1043, // 757: forge.MachineValidationRunItem.timeout:type_name -> google.protobuf.Duration + 1019, // 758: forge.MachineValidationRunItem.started_at:type_name -> google.protobuf.Timestamp + 1019, // 759: forge.MachineValidationRunItem.ended_at:type_name -> google.protobuf.Timestamp + 1019, // 760: forge.MachineValidationRunItem.last_heartbeat_at:type_name -> google.protobuf.Timestamp + 1030, // 761: forge.MachineValidationRunItem.current_attempt_id:type_name -> common.UUID + 1030, // 762: forge.MachineValidationAttemptGetRequest.attempt_id:type_name -> common.UUID + 1030, // 763: forge.MachineValidationAttempt.attempt_id:type_name -> common.UUID + 1030, // 764: forge.MachineValidationAttempt.run_item_id:type_name -> common.UUID + 1019, // 765: forge.MachineValidationAttempt.started_at:type_name -> google.protobuf.Timestamp + 1019, // 766: forge.MachineValidationAttempt.ended_at:type_name -> google.protobuf.Timestamp + 1019, // 767: forge.MachineValidationAttempt.last_heartbeat_at:type_name -> google.protobuf.Timestamp + 1047, // 768: forge.MachineValidationHeartbeatRequest.validation_id:type_name -> common.MachineValidationId + 1030, // 769: forge.MachineValidationHeartbeatRequest.run_item_id:type_name -> common.UUID + 1030, // 770: forge.MachineValidationHeartbeatRequest.attempt_id:type_name -> common.UUID + 1010, // 771: forge.MachineValidationTestUpdateRequest.payload:type_name -> forge.MachineValidationTestUpdateRequest.Payload + 637, // 772: forge.MachineValidationTestsGetResponse.tests:type_name -> forge.MachineValidationTest + 1047, // 773: forge.MachineValidationRunRequest.validation_id:type_name -> common.MachineValidationId + 1043, // 774: forge.MachineValidationRunRequest.duration_to_complete:type_name -> google.protobuf.Duration + 637, // 775: forge.MachineValidationRunRequest.selected_tests:type_name -> forge.MachineValidationTest + 56, // 776: forge.MachineCapabilityAttributesGpu.device_type:type_name -> forge.MachineCapabilityDeviceType + 56, // 777: forge.MachineCapabilityAttributesNetwork.device_type:type_name -> forge.MachineCapabilityDeviceType + 644, // 778: forge.MachineCapabilitiesSet.cpu:type_name -> forge.MachineCapabilityAttributesCpu + 645, // 779: forge.MachineCapabilitiesSet.gpu:type_name -> forge.MachineCapabilityAttributesGpu + 646, // 780: forge.MachineCapabilitiesSet.memory:type_name -> forge.MachineCapabilityAttributesMemory + 647, // 781: forge.MachineCapabilitiesSet.storage:type_name -> forge.MachineCapabilityAttributesStorage + 648, // 782: forge.MachineCapabilitiesSet.network:type_name -> forge.MachineCapabilityAttributesNetwork + 649, // 783: forge.MachineCapabilitiesSet.infiniband:type_name -> forge.MachineCapabilityAttributesInfiniband + 650, // 784: forge.MachineCapabilitiesSet.dpu:type_name -> forge.MachineCapabilityAttributesDpu + 654, // 785: forge.InstanceTypeAttributes.desired_capabilities:type_name -> forge.InstanceTypeMachineCapabilityFilterAttributes + 652, // 786: forge.InstanceType.attributes:type_name -> forge.InstanceTypeAttributes + 273, // 787: forge.InstanceType.metadata:type_name -> forge.Metadata + 752, // 788: forge.InstanceType.allocation_stats:type_name -> forge.InstanceTypeAllocationStats + 57, // 789: forge.InstanceTypeMachineCapabilityFilterAttributes.capability_type:type_name -> forge.MachineCapabilityType + 1048, // 790: forge.InstanceTypeMachineCapabilityFilterAttributes.inactive_devices:type_name -> common.Uint32List + 56, // 791: forge.InstanceTypeMachineCapabilityFilterAttributes.device_type:type_name -> forge.MachineCapabilityDeviceType + 273, // 792: forge.CreateInstanceTypeRequest.metadata:type_name -> forge.Metadata + 652, // 793: forge.CreateInstanceTypeRequest.instance_type_attributes:type_name -> forge.InstanceTypeAttributes + 653, // 794: forge.CreateInstanceTypeResponse.instance_type:type_name -> forge.InstanceType + 653, // 795: forge.FindInstanceTypesByIdsResponse.instance_types:type_name -> forge.InstanceType + 653, // 796: forge.UpdateInstanceTypeResponse.instance_type:type_name -> forge.InstanceType + 273, // 797: forge.UpdateInstanceTypeRequest.metadata:type_name -> forge.Metadata + 652, // 798: forge.UpdateInstanceTypeRequest.instance_type_attributes:type_name -> forge.InstanceTypeAttributes + 1011, // 799: forge.RedfishBrowseResponse.headers:type_name -> forge.RedfishBrowseResponse.HeadersEntry + 673, // 800: forge.RedfishListActionsResponse.actions:type_name -> forge.RedfishAction + 1019, // 801: forge.RedfishAction.approver_dates:type_name -> google.protobuf.Timestamp + 1019, // 802: forge.RedfishAction.applied_at:type_name -> google.protobuf.Timestamp + 674, // 803: forge.RedfishAction.results:type_name -> forge.OptionalRedfishActionResult + 675, // 804: forge.OptionalRedfishActionResult.result:type_name -> forge.RedfishActionResult + 1012, // 805: forge.RedfishActionResult.headers:type_name -> forge.RedfishActionResult.HeadersEntry + 1019, // 806: forge.RedfishActionResult.completed_at:type_name -> google.protobuf.Timestamp + 1013, // 807: forge.UfmBrowseResponse.headers:type_name -> forge.UfmBrowseResponse.HeadersEntry + 701, // 808: forge.NetworkSecurityGroupAttributes.rules:type_name -> forge.NetworkSecurityGroupRuleAttributes + 273, // 809: forge.NetworkSecurityGroup.metadata:type_name -> forge.Metadata + 684, // 810: forge.NetworkSecurityGroup.attributes:type_name -> forge.NetworkSecurityGroupAttributes + 273, // 811: forge.CreateNetworkSecurityGroupRequest.metadata:type_name -> forge.Metadata + 684, // 812: forge.CreateNetworkSecurityGroupRequest.network_security_group_attributes:type_name -> forge.NetworkSecurityGroupAttributes + 685, // 813: forge.CreateNetworkSecurityGroupResponse.network_security_group:type_name -> forge.NetworkSecurityGroup + 685, // 814: forge.FindNetworkSecurityGroupsByIdsResponse.network_security_groups:type_name -> forge.NetworkSecurityGroup + 685, // 815: forge.UpdateNetworkSecurityGroupResponse.network_security_group:type_name -> forge.NetworkSecurityGroup + 273, // 816: forge.UpdateNetworkSecurityGroupRequest.metadata:type_name -> forge.Metadata + 684, // 817: forge.UpdateNetworkSecurityGroupRequest.network_security_group_attributes:type_name -> forge.NetworkSecurityGroupAttributes + 58, // 818: forge.NetworkSecurityGroupStatus.source:type_name -> forge.NetworkSecurityGroupSource + 59, // 819: forge.NetworkSecurityGroupPropagationObjectStatus.status:type_name -> forge.NetworkSecurityGroupPropagationStatus + 697, // 820: forge.GetNetworkSecurityGroupPropagationStatusResponse.vpcs:type_name -> forge.NetworkSecurityGroupPropagationObjectStatus + 697, // 821: forge.GetNetworkSecurityGroupPropagationStatusResponse.instances:type_name -> forge.NetworkSecurityGroupPropagationObjectStatus + 699, // 822: forge.GetNetworkSecurityGroupPropagationStatusRequest.network_security_group_ids:type_name -> forge.NetworkSecurityGroupIdList + 60, // 823: forge.NetworkSecurityGroupRuleAttributes.direction:type_name -> forge.NetworkSecurityGroupRuleDirection + 61, // 824: forge.NetworkSecurityGroupRuleAttributes.protocol:type_name -> forge.NetworkSecurityGroupRuleProtocol + 62, // 825: forge.NetworkSecurityGroupRuleAttributes.action:type_name -> forge.NetworkSecurityGroupRuleAction + 701, // 826: forge.ResolvedNetworkSecurityGroupRule.rule:type_name -> forge.NetworkSecurityGroupRuleAttributes + 704, // 827: forge.GetNetworkSecurityGroupAttachmentsResponse.attachments:type_name -> forge.NetworkSecurityGroupAttachments + 708, // 828: forge.GetDesiredFirmwareVersionsResponse.entries:type_name -> forge.DesiredFirmwareVersionEntry + 1014, // 829: forge.DesiredFirmwareVersionEntry.component_versions:type_name -> forge.DesiredFirmwareVersionEntry.ComponentVersionsEntry + 709, // 830: forge.SkuComponents.chassis:type_name -> forge.SkuComponentChassis + 710, // 831: forge.SkuComponents.cpus:type_name -> forge.SkuComponentCpu + 711, // 832: forge.SkuComponents.gpus:type_name -> forge.SkuComponentGpu + 712, // 833: forge.SkuComponents.ethernet_devices:type_name -> forge.SkuComponentEthernetDevices + 713, // 834: forge.SkuComponents.infiniband_devices:type_name -> forge.SkuComponentInfinibandDevices + 714, // 835: forge.SkuComponents.storage:type_name -> forge.SkuComponentStorage + 716, // 836: forge.SkuComponents.memory:type_name -> forge.SkuComponentMemory + 717, // 837: forge.SkuComponents.tpm:type_name -> forge.SkuComponentTpm + 1019, // 838: forge.Sku.created:type_name -> google.protobuf.Timestamp + 718, // 839: forge.Sku.components:type_name -> forge.SkuComponents + 1018, // 840: forge.Sku.associated_machine_ids:type_name -> common.MachineId + 1018, // 841: forge.SkuMachinePair.machine_id:type_name -> common.MachineId + 1018, // 842: forge.RemoveSkuRequest.machine_id:type_name -> common.MachineId + 719, // 843: forge.SkuList.skus:type_name -> forge.Sku + 1019, // 844: forge.SkuStatus.verify_request_time:type_name -> google.protobuf.Timestamp + 1019, // 845: forge.SkuStatus.last_match_attempt:type_name -> google.protobuf.Timestamp + 1019, // 846: forge.SkuStatus.last_generate_attempt:type_name -> google.protobuf.Timestamp + 1049, // 847: forge.DpaInterface.id:type_name -> common.DpaInterfaceId + 1018, // 848: forge.DpaInterface.machine_id:type_name -> common.MachineId + 1019, // 849: forge.DpaInterface.created:type_name -> google.protobuf.Timestamp + 1019, // 850: forge.DpaInterface.updated:type_name -> google.protobuf.Timestamp + 1019, // 851: forge.DpaInterface.deleted:type_name -> google.protobuf.Timestamp + 237, // 852: forge.DpaInterface.history:type_name -> forge.StateHistoryRecord + 1019, // 853: forge.DpaInterface.last_hb_time:type_name -> google.protobuf.Timestamp + 63, // 854: forge.DpaInterface.interface_type:type_name -> forge.DpaInterfaceType + 1018, // 855: forge.DpaInterfaceCreationRequest.machine_id:type_name -> common.MachineId + 63, // 856: forge.DpaInterfaceCreationRequest.interface_type:type_name -> forge.DpaInterfaceType + 1049, // 857: forge.DpaInterfaceIdList.ids:type_name -> common.DpaInterfaceId + 1049, // 858: forge.DpaInterfacesByIdsRequest.ids:type_name -> common.DpaInterfaceId + 727, // 859: forge.DpaInterfaceList.interfaces:type_name -> forge.DpaInterface + 1049, // 860: forge.DpaNetworkObservationSetRequest.id:type_name -> common.DpaInterfaceId + 1049, // 861: forge.DpaInterfaceDeletionRequest.id:type_name -> common.DpaInterfaceId + 1018, // 862: forge.PowerOptionRequest.machine_id:type_name -> common.MachineId + 1018, // 863: forge.PowerOptionUpdateRequest.machine_id:type_name -> common.MachineId + 64, // 864: forge.PowerOptionUpdateRequest.power_state:type_name -> forge.PowerState + 64, // 865: forge.PowerOptions.desired_state:type_name -> forge.PowerState + 1019, // 866: forge.PowerOptions.desired_state_updated_at:type_name -> google.protobuf.Timestamp + 64, // 867: forge.PowerOptions.actual_state:type_name -> forge.PowerState + 1019, // 868: forge.PowerOptions.actual_state_updated_at:type_name -> google.protobuf.Timestamp + 1018, // 869: forge.PowerOptions.host_id:type_name -> common.MachineId + 1019, // 870: forge.PowerOptions.next_power_state_fetch_at:type_name -> google.protobuf.Timestamp + 1019, // 871: forge.PowerOptions.tried_triggering_on_at:type_name -> google.protobuf.Timestamp + 1019, // 872: forge.PowerOptions.wait_until_time_before_performing_next_power_action:type_name -> google.protobuf.Timestamp + 738, // 873: forge.PowerOptionResponse.response:type_name -> forge.PowerOptions + 1050, // 874: forge.ComputeAllocation.id:type_name -> common.ComputeAllocationId + 740, // 875: forge.ComputeAllocation.attributes:type_name -> forge.ComputeAllocationAttributes + 273, // 876: forge.ComputeAllocation.metadata:type_name -> forge.Metadata + 1050, // 877: forge.CreateComputeAllocationRequest.id:type_name -> common.ComputeAllocationId + 273, // 878: forge.CreateComputeAllocationRequest.metadata:type_name -> forge.Metadata + 740, // 879: forge.CreateComputeAllocationRequest.attributes:type_name -> forge.ComputeAllocationAttributes + 741, // 880: forge.CreateComputeAllocationResponse.allocation:type_name -> forge.ComputeAllocation + 1050, // 881: forge.FindComputeAllocationIdsResponse.ids:type_name -> common.ComputeAllocationId + 1050, // 882: forge.FindComputeAllocationsByIdsRequest.ids:type_name -> common.ComputeAllocationId + 741, // 883: forge.FindComputeAllocationsByIdsResponse.allocations:type_name -> forge.ComputeAllocation + 741, // 884: forge.UpdateComputeAllocationResponse.allocation:type_name -> forge.ComputeAllocation + 1050, // 885: forge.UpdateComputeAllocationRequest.id:type_name -> common.ComputeAllocationId + 273, // 886: forge.UpdateComputeAllocationRequest.metadata:type_name -> forge.Metadata + 740, // 887: forge.UpdateComputeAllocationRequest.attributes:type_name -> forge.ComputeAllocationAttributes + 1050, // 888: forge.DeleteComputeAllocationRequest.id:type_name -> common.ComputeAllocationId + 759, // 889: forge.GetRackResponse.rack:type_name -> forge.Rack + 759, // 890: forge.RackList.racks:type_name -> forge.Rack + 272, // 891: forge.RackSearchFilter.label:type_name -> forge.Label + 1029, // 892: forge.RackIdList.rack_ids:type_name -> common.RackId + 1029, // 893: forge.RacksByIdsRequest.rack_ids:type_name -> common.RackId + 1029, // 894: forge.Rack.id:type_name -> common.RackId + 1019, // 895: forge.Rack.created:type_name -> google.protobuf.Timestamp + 1019, // 896: forge.Rack.updated:type_name -> google.protobuf.Timestamp + 1019, // 897: forge.Rack.deleted:type_name -> google.protobuf.Timestamp + 273, // 898: forge.Rack.metadata:type_name -> forge.Metadata + 760, // 899: forge.Rack.config:type_name -> forge.RackConfig + 761, // 900: forge.Rack.status:type_name -> forge.RackStatus + 1027, // 901: forge.RackStatus.health:type_name -> health.HealthReport + 363, // 902: forge.RackStatus.health_sources:type_name -> forge.HealthSourceOrigin + 101, // 903: forge.RackStatus.lifecycle:type_name -> forge.LifecycleStatus + 1029, // 904: forge.RackStateHistoriesRequest.rack_ids:type_name -> common.RackId + 1029, // 905: forge.AdminForceDeleteRackRequest.rack_id:type_name -> common.RackId + 766, // 906: forge.RackCapabilitiesSet.compute:type_name -> forge.RackCapabilityCompute + 767, // 907: forge.RackCapabilitiesSet.switch:type_name -> forge.RackCapabilitySwitch + 768, // 908: forge.RackCapabilitiesSet.power_shelf:type_name -> forge.RackCapabilityPowerShelf + 1051, // 909: forge.RackProfile.rack_hardware_type:type_name -> common.RackHardwareType + 65, // 910: forge.RackProfile.rack_hardware_topology:type_name -> forge.RackHardwareTopology + 67, // 911: forge.RackProfile.rack_hardware_class:type_name -> forge.RackHardwareClass + 769, // 912: forge.RackProfile.capabilities:type_name -> forge.RackCapabilitiesSet + 66, // 913: forge.RackProfile.product_family:type_name -> forge.RackProductFamily + 1029, // 914: forge.GetRackProfileRequest.rack_id:type_name -> common.RackId + 1029, // 915: forge.GetRackProfileResponse.rack_id:type_name -> common.RackId + 1032, // 916: forge.GetRackProfileResponse.rack_profile_id:type_name -> common.RackProfileId + 770, // 917: forge.GetRackProfileResponse.profile:type_name -> forge.RackProfile + 68, // 918: forge.RackManagerForgeRequest.cmd:type_name -> forge.RackManagerForgeCmd + 1040, // 919: forge.MachineNVLinkInfo.domain_uuid:type_name -> common.NVLinkDomainId + 784, // 920: forge.MachineNVLinkInfo.gpus:type_name -> forge.NVLinkGpu + 1018, // 921: forge.UpdateMachineNvLinkInfoRequest.machine_id:type_name -> common.MachineId + 775, // 922: forge.UpdateMachineNvLinkInfoRequest.nvlink_info:type_name -> forge.MachineNVLinkInfo + 778, // 923: forge.MachineSpxStatusObservation.attachment_status:type_name -> forge.MachineSpxAttachmentStatusObservation + 1019, // 924: forge.MachineSpxStatusObservation.observed_at:type_name -> google.protobuf.Timestamp + 1039, // 925: forge.MachineSpxAttachmentStatusObservation.partition_id:type_name -> common.SpxPartitionId + 16, // 926: forge.MachineSpxAttachmentStatusObservation.attachment_type:type_name -> forge.SpxAttachmentType + 1019, // 927: forge.MachineSpxAttachmentStatusObservation.observed_at:type_name -> google.protobuf.Timestamp + 780, // 928: forge.AstraConfig.astra_attachments:type_name -> forge.AstraAttachment + 16, // 929: forge.AstraAttachment.attachment_type:type_name -> forge.SpxAttachmentType + 782, // 930: forge.AstraConfigStatus.astra_attachments_status:type_name -> forge.AstraAttachmentStatus + 16, // 931: forge.AstraAttachmentStatus.attachment_type:type_name -> forge.SpxAttachmentType + 783, // 932: forge.AstraAttachmentStatus.status:type_name -> forge.AstraStatus + 69, // 933: forge.AstraStatus.phase:type_name -> forge.AstraPhase + 786, // 934: forge.MachineNVLinkStatusObservation.gpu_status:type_name -> forge.MachineNVLinkGpuStatusObservation + 1052, // 935: forge.MachineNVLinkGpuStatusObservation.partition_id:type_name -> common.NVLinkPartitionId + 1023, // 936: forge.MachineNVLinkGpuStatusObservation.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 1040, // 937: forge.MachineNVLinkGpuStatusObservation.domain_id:type_name -> common.NVLinkDomainId + 70, // 938: forge.NmxcBrowseRequest.operation:type_name -> forge.NmxcBrowseOperation + 1015, // 939: forge.NmxcBrowseResponse.headers:type_name -> forge.NmxcBrowseResponse.HeadersEntry + 1052, // 940: forge.NVLinkPartition.id:type_name -> common.NVLinkPartitionId + 1040, // 941: forge.NVLinkPartition.domain_uuid:type_name -> common.NVLinkDomainId + 1023, // 942: forge.NVLinkPartition.logical_partition_id:type_name -> common.NVLinkLogicalPartitionId + 789, // 943: forge.NVLinkPartitionList.partitions:type_name -> forge.NVLinkPartition + 1030, // 944: forge.NVLinkPartitionQuery.id:type_name -> common.UUID + 791, // 945: forge.NVLinkPartitionQuery.search_config:type_name -> forge.NVLinkPartitionSearchConfig + 1052, // 946: forge.NVLinkPartitionsByIdsRequest.partition_ids:type_name -> common.NVLinkPartitionId + 1052, // 947: forge.NVLinkPartitionIdList.partition_ids:type_name -> common.NVLinkPartitionId + 273, // 948: forge.NVLinkLogicalPartitionConfig.metadata:type_name -> forge.Metadata + 8, // 949: forge.NVLinkLogicalPartitionStatus.state:type_name -> forge.TenantState + 1023, // 950: forge.NVLinkLogicalPartition.id:type_name -> common.NVLinkLogicalPartitionId + 797, // 951: forge.NVLinkLogicalPartition.config:type_name -> forge.NVLinkLogicalPartitionConfig + 798, // 952: forge.NVLinkLogicalPartition.status:type_name -> forge.NVLinkLogicalPartitionStatus + 1019, // 953: forge.NVLinkLogicalPartition.created:type_name -> google.protobuf.Timestamp + 799, // 954: forge.NVLinkLogicalPartitionList.partitions:type_name -> forge.NVLinkLogicalPartition + 797, // 955: forge.NVLinkLogicalPartitionCreationRequest.config:type_name -> forge.NVLinkLogicalPartitionConfig + 1023, // 956: forge.NVLinkLogicalPartitionCreationRequest.id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 957: forge.NVLinkLogicalPartitionDeletionRequest.id:type_name -> common.NVLinkLogicalPartitionId + 1023, // 958: forge.NVLinkLogicalPartitionsByIdsRequest.partition_ids:type_name -> common.NVLinkLogicalPartitionId + 1023, // 959: forge.NVLinkLogicalPartitionIdList.partition_ids:type_name -> common.NVLinkLogicalPartitionId + 1023, // 960: forge.NVLinkLogicalPartitionUpdateRequest.id:type_name -> common.NVLinkLogicalPartitionId + 797, // 961: forge.NVLinkLogicalPartitionUpdateRequest.config:type_name -> forge.NVLinkLogicalPartitionConfig + 390, // 962: forge.CreateBmcUserRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest + 390, // 963: forge.DeleteBmcUserRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest + 390, // 964: forge.SetBmcRootPasswordRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest + 390, // 965: forge.ProbeBmcVendorRequest.bmc_endpoint_request:type_name -> forge.BmcEndpointRequest + 1018, // 966: forge.SetFirmwareUpdateTimeWindowRequest.machine_ids:type_name -> common.MachineId + 1019, // 967: forge.SetFirmwareUpdateTimeWindowRequest.start_timestamp:type_name -> google.protobuf.Timestamp + 1019, // 968: forge.SetFirmwareUpdateTimeWindowRequest.end_timestamp:type_name -> google.protobuf.Timestamp + 821, // 969: forge.UpsertHostFirmwareConfigRequest.components:type_name -> forge.UpsertHostFirmwareComponentConfig + 71, // 970: forge.UpsertHostFirmwareConfigRequest.ordering:type_name -> forge.HostFirmwareComponentType + 71, // 971: forge.UpsertHostFirmwareComponentConfig.type:type_name -> forge.HostFirmwareComponentType + 823, // 972: forge.UpsertHostFirmwareComponentConfig.firmware:type_name -> forge.HostFirmwareVersionConfig + 71, // 973: forge.HostFirmwareComponentConfigResponse.type:type_name -> forge.HostFirmwareComponentType + 823, // 974: forge.HostFirmwareComponentConfigResponse.firmware:type_name -> forge.HostFirmwareVersionConfig + 824, // 975: forge.HostFirmwareVersionConfig.artifacts:type_name -> forge.HostFirmwareArtifact + 822, // 976: forge.HostFirmwareConfigResponse.components:type_name -> forge.HostFirmwareComponentConfigResponse + 71, // 977: forge.HostFirmwareConfigResponse.ordering:type_name -> forge.HostFirmwareComponentType + 1019, // 978: forge.HostFirmwareConfigResponse.created_at:type_name -> google.protobuf.Timestamp + 1019, // 979: forge.HostFirmwareConfigResponse.updated_at:type_name -> google.protobuf.Timestamp + 828, // 980: forge.ListHostFirmwareResponse.available:type_name -> forge.AvailableHostFirmware + 72, // 981: forge.TrimTableRequest.target:type_name -> forge.TrimTableTarget + 831, // 982: forge.NvlinkNmxcEndpointList.entries:type_name -> forge.NvlinkNmxcEndpoint + 273, // 983: forge.CreateRemediationRequest.metadata:type_name -> forge.Metadata + 1053, // 984: forge.CreateRemediationResponse.remediation_id:type_name -> common.RemediationId + 1053, // 985: forge.RemediationIdList.remediation_ids:type_name -> common.RemediationId + 838, // 986: forge.RemediationList.remediations:type_name -> forge.Remediation + 1053, // 987: forge.Remediation.id:type_name -> common.RemediationId + 273, // 988: forge.Remediation.metadata:type_name -> forge.Metadata + 1019, // 989: forge.Remediation.creation_time:type_name -> google.protobuf.Timestamp + 1053, // 990: forge.ApproveRemediationRequest.remediation_id:type_name -> common.RemediationId + 1053, // 991: forge.RevokeRemediationRequest.remediation_id:type_name -> common.RemediationId + 1053, // 992: forge.EnableRemediationRequest.remediation_id:type_name -> common.RemediationId + 1053, // 993: forge.DisableRemediationRequest.remediation_id:type_name -> common.RemediationId + 1053, // 994: forge.FindAppliedRemediationIdsRequest.remediation_id:type_name -> common.RemediationId + 1018, // 995: forge.FindAppliedRemediationIdsRequest.dpu_machine_id:type_name -> common.MachineId + 1053, // 996: forge.AppliedRemediationIdList.remediation_ids:type_name -> common.RemediationId + 1018, // 997: forge.AppliedRemediationIdList.dpu_machine_ids:type_name -> common.MachineId + 1053, // 998: forge.FindAppliedRemediationsRequest.remediation_id:type_name -> common.RemediationId + 1018, // 999: forge.FindAppliedRemediationsRequest.dpu_machine_id:type_name -> common.MachineId + 1053, // 1000: forge.AppliedRemediation.remediation_id:type_name -> common.RemediationId + 1018, // 1001: forge.AppliedRemediation.dpu_machine_id:type_name -> common.MachineId + 1019, // 1002: forge.AppliedRemediation.applied_time:type_name -> google.protobuf.Timestamp + 273, // 1003: forge.AppliedRemediation.metadata:type_name -> forge.Metadata + 846, // 1004: forge.AppliedRemediationList.applied_remediations:type_name -> forge.AppliedRemediation + 1018, // 1005: forge.GetNextRemediationForMachineRequest.dpu_machine_id:type_name -> common.MachineId + 1053, // 1006: forge.GetNextRemediationForMachineResponse.remediation_id:type_name -> common.RemediationId + 1053, // 1007: forge.RemediationAppliedRequest.remediation_id:type_name -> common.RemediationId + 1018, // 1008: forge.RemediationAppliedRequest.dpu_machine_id:type_name -> common.MachineId + 851, // 1009: forge.RemediationAppliedRequest.status:type_name -> forge.RemediationApplicationStatus + 273, // 1010: forge.RemediationApplicationStatus.metadata:type_name -> forge.Metadata + 1018, // 1011: forge.SetPrimaryDpuRequest.host_machine_id:type_name -> common.MachineId + 1018, // 1012: forge.SetPrimaryDpuRequest.dpu_machine_id:type_name -> common.MachineId + 1018, // 1013: forge.SetPrimaryInterfaceRequest.host_machine_id:type_name -> common.MachineId + 1041, // 1014: forge.SetPrimaryInterfaceRequest.interface_id:type_name -> common.MachineInterfaceId + 854, // 1015: forge.DpuExtensionServiceCredential.username_password:type_name -> forge.UsernamePassword + 875, // 1016: forge.DpuExtensionServiceVersionInfo.observability:type_name -> forge.DpuExtensionServiceObservability + 73, // 1017: forge.DpuExtensionService.service_type:type_name -> forge.DpuExtensionServiceType + 857, // 1018: forge.DpuExtensionService.latest_version_info:type_name -> forge.DpuExtensionServiceVersionInfo + 73, // 1019: forge.CreateDpuExtensionServiceRequest.service_type:type_name -> forge.DpuExtensionServiceType + 856, // 1020: forge.CreateDpuExtensionServiceRequest.credential:type_name -> forge.DpuExtensionServiceCredential + 875, // 1021: forge.CreateDpuExtensionServiceRequest.observability:type_name -> forge.DpuExtensionServiceObservability + 856, // 1022: forge.UpdateDpuExtensionServiceRequest.credential:type_name -> forge.DpuExtensionServiceCredential + 875, // 1023: forge.UpdateDpuExtensionServiceRequest.observability:type_name -> forge.DpuExtensionServiceObservability + 73, // 1024: forge.DpuExtensionServiceSearchFilter.service_type:type_name -> forge.DpuExtensionServiceType + 858, // 1025: forge.DpuExtensionServiceList.services:type_name -> forge.DpuExtensionService + 857, // 1026: forge.DpuExtensionServiceVersionInfoList.version_infos:type_name -> forge.DpuExtensionServiceVersionInfo + 871, // 1027: forge.FindInstancesByDpuExtensionServiceResponse.instances:type_name -> forge.InstanceDpuExtensionServiceInfo + 872, // 1028: forge.DpuExtensionServiceObservabilityConfig.prometheus:type_name -> forge.DpuExtensionServiceObservabilityConfigPrometheus + 873, // 1029: forge.DpuExtensionServiceObservabilityConfig.logging:type_name -> forge.DpuExtensionServiceObservabilityConfigLogging + 874, // 1030: forge.DpuExtensionServiceObservability.configs:type_name -> forge.DpuExtensionServiceObservabilityConfig + 1030, // 1031: forge.ScoutStreamApiBoundMessage.flow_uuid:type_name -> common.UUID + 878, // 1032: forge.ScoutStreamApiBoundMessage.init:type_name -> forge.ScoutStreamInitRequest + 1054, // 1033: forge.ScoutStreamApiBoundMessage.mlx_device_lockdown_response:type_name -> mlx_device.MlxDeviceLockdownResponse + 1055, // 1034: forge.ScoutStreamApiBoundMessage.mlx_device_profile_sync_response:type_name -> mlx_device.MlxDeviceProfileSyncResponse + 1056, // 1035: forge.ScoutStreamApiBoundMessage.mlx_device_profile_compare_response:type_name -> mlx_device.MlxDeviceProfileCompareResponse + 1057, // 1036: forge.ScoutStreamApiBoundMessage.mlx_device_info_device_response:type_name -> mlx_device.MlxDeviceInfoDeviceResponse + 1058, // 1037: forge.ScoutStreamApiBoundMessage.mlx_device_info_report_response:type_name -> mlx_device.MlxDeviceInfoReportResponse + 1059, // 1038: forge.ScoutStreamApiBoundMessage.mlx_device_registry_list_response:type_name -> mlx_device.MlxDeviceRegistryListResponse + 1060, // 1039: forge.ScoutStreamApiBoundMessage.mlx_device_registry_show_response:type_name -> mlx_device.MlxDeviceRegistryShowResponse + 1061, // 1040: forge.ScoutStreamApiBoundMessage.mlx_device_config_query_response:type_name -> mlx_device.MlxDeviceConfigQueryResponse + 1062, // 1041: forge.ScoutStreamApiBoundMessage.mlx_device_config_set_response:type_name -> mlx_device.MlxDeviceConfigSetResponse + 1063, // 1042: forge.ScoutStreamApiBoundMessage.mlx_device_config_sync_response:type_name -> mlx_device.MlxDeviceConfigSyncResponse + 1064, // 1043: forge.ScoutStreamApiBoundMessage.mlx_device_config_compare_response:type_name -> mlx_device.MlxDeviceConfigCompareResponse + 886, // 1044: forge.ScoutStreamApiBoundMessage.scout_stream_agent_ping_response:type_name -> forge.ScoutStreamAgentPingResponse + 1030, // 1045: forge.ScoutStreamScoutBoundMessage.flow_uuid:type_name -> common.UUID + 1065, // 1046: forge.ScoutStreamScoutBoundMessage.mlx_device_lockdown_lock_request:type_name -> mlx_device.MlxDeviceLockdownLockRequest + 1066, // 1047: forge.ScoutStreamScoutBoundMessage.mlx_device_lockdown_unlock_request:type_name -> mlx_device.MlxDeviceLockdownUnlockRequest + 1067, // 1048: forge.ScoutStreamScoutBoundMessage.mlx_device_lockdown_status_request:type_name -> mlx_device.MlxDeviceLockdownStatusRequest + 1068, // 1049: forge.ScoutStreamScoutBoundMessage.mlx_device_profile_sync_request:type_name -> mlx_device.MlxDeviceProfileSyncRequest + 1069, // 1050: forge.ScoutStreamScoutBoundMessage.mlx_device_profile_compare_request:type_name -> mlx_device.MlxDeviceProfileCompareRequest + 1070, // 1051: forge.ScoutStreamScoutBoundMessage.mlx_device_info_device_request:type_name -> mlx_device.MlxDeviceInfoDeviceRequest + 1071, // 1052: forge.ScoutStreamScoutBoundMessage.mlx_device_info_report_request:type_name -> mlx_device.MlxDeviceInfoReportRequest + 1072, // 1053: forge.ScoutStreamScoutBoundMessage.mlx_device_registry_list_request:type_name -> mlx_device.MlxDeviceRegistryListRequest + 1073, // 1054: forge.ScoutStreamScoutBoundMessage.mlx_device_registry_show_request:type_name -> mlx_device.MlxDeviceRegistryShowRequest + 1074, // 1055: forge.ScoutStreamScoutBoundMessage.mlx_device_config_query_request:type_name -> mlx_device.MlxDeviceConfigQueryRequest + 1075, // 1056: forge.ScoutStreamScoutBoundMessage.mlx_device_config_set_request:type_name -> mlx_device.MlxDeviceConfigSetRequest + 1076, // 1057: forge.ScoutStreamScoutBoundMessage.mlx_device_config_sync_request:type_name -> mlx_device.MlxDeviceConfigSyncRequest + 1077, // 1058: forge.ScoutStreamScoutBoundMessage.mlx_device_config_compare_request:type_name -> mlx_device.MlxDeviceConfigCompareRequest + 885, // 1059: forge.ScoutStreamScoutBoundMessage.scout_stream_agent_ping_request:type_name -> forge.ScoutStreamAgentPingRequest + 1018, // 1060: forge.ScoutStreamInitRequest.machine_id:type_name -> common.MachineId + 887, // 1061: forge.ScoutStreamShowConnectionsResponse.scout_stream_connections:type_name -> forge.ScoutStreamConnectionInfo + 1018, // 1062: forge.ScoutStreamDisconnectRequest.machine_id:type_name -> common.MachineId + 1018, // 1063: forge.ScoutStreamDisconnectResponse.machine_id:type_name -> common.MachineId + 1018, // 1064: forge.ScoutStreamAdminPingRequest.machine_id:type_name -> common.MachineId + 888, // 1065: forge.ScoutStreamAgentPingResponse.error:type_name -> forge.ScoutStreamError + 1018, // 1066: forge.ScoutStreamConnectionInfo.machine_id:type_name -> common.MachineId + 75, // 1067: forge.ScoutStreamError.status:type_name -> forge.ScoutStreamErrorStatus + 1022, // 1068: forge.RoutingProfile.route_target_imports:type_name -> common.RouteTarget + 1022, // 1069: forge.RoutingProfile.route_targets_on_exports:type_name -> common.RouteTarget + 889, // 1070: forge.RoutingProfile.accepted_leaks_from_underlay:type_name -> forge.PrefixFilterPolicyEntry + 889, // 1071: forge.RoutingProfile.allowed_anycast_prefixes:type_name -> forge.PrefixFilterPolicyEntry + 1033, // 1072: forge.DomainLegacy.id:type_name -> common.DomainId + 1019, // 1073: forge.DomainLegacy.created:type_name -> google.protobuf.Timestamp + 1019, // 1074: forge.DomainLegacy.updated:type_name -> google.protobuf.Timestamp + 1019, // 1075: forge.DomainLegacy.deleted:type_name -> google.protobuf.Timestamp + 891, // 1076: forge.DomainListLegacy.domains:type_name -> forge.DomainLegacy + 1033, // 1077: forge.DomainDeletionLegacy.id:type_name -> common.DomainId + 1033, // 1078: forge.DomainSearchQueryLegacy.id:type_name -> common.DomainId + 1078, // 1079: forge.PxeDomain.new_domain:type_name -> dns.Domain + 891, // 1080: forge.PxeDomain.legacy_domain:type_name -> forge.DomainLegacy + 1018, // 1081: forge.MachinePositionQuery.machine_ids:type_name -> common.MachineId + 899, // 1082: forge.MachinePositionInfoList.machine_position_info:type_name -> forge.MachinePositionInfo + 1018, // 1083: forge.MachinePositionInfo.machine_id:type_name -> common.MachineId + 1031, // 1084: forge.MachinePositionInfo.switch_id:type_name -> common.SwitchId + 1028, // 1085: forge.MachinePositionInfo.power_shelf_id:type_name -> common.PowerShelfId + 1018, // 1086: forge.ModifyDPFStateRequest.machine_id:type_name -> common.MachineId + 1016, // 1087: forge.DPFStateResponse.dpf_states:type_name -> forge.DPFStateResponse.DPFState + 1018, // 1088: forge.GetDPFStateRequest.machine_ids:type_name -> common.MachineId + 1018, // 1089: forge.GetDPFHostSnapshotRequest.host_machine_id:type_name -> common.MachineId + 906, // 1090: forge.DPFServiceVersionsResponse.services:type_name -> forge.DPFServiceVersion + 76, // 1091: forge.ComponentResult.status:type_name -> forge.ComponentManagerStatusCode + 1031, // 1092: forge.SwitchIdList.ids:type_name -> common.SwitchId + 1028, // 1093: forge.PowerShelfIdList.ids:type_name -> common.PowerShelfId + 1079, // 1094: forge.GetComponentInventoryRequest.machine_ids:type_name -> common.MachineIdList + 909, // 1095: forge.GetComponentInventoryRequest.switch_ids:type_name -> forge.SwitchIdList + 910, // 1096: forge.GetComponentInventoryRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList + 908, // 1097: forge.ComponentInventoryEntry.result:type_name -> forge.ComponentResult + 1080, // 1098: forge.ComponentInventoryEntry.report:type_name -> site_explorer.EndpointExplorationReport + 912, // 1099: forge.GetComponentInventoryResponse.entries:type_name -> forge.ComponentInventoryEntry + 1079, // 1100: forge.ComponentPowerControlRequest.machine_ids:type_name -> common.MachineIdList + 909, // 1101: forge.ComponentPowerControlRequest.switch_ids:type_name -> forge.SwitchIdList + 910, // 1102: forge.ComponentPowerControlRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList + 1081, // 1103: forge.ComponentPowerControlRequest.action:type_name -> common.SystemPowerControl + 908, // 1104: forge.ComponentPowerControlResponse.results:type_name -> forge.ComponentResult + 909, // 1105: forge.ComponentConfigureSwitchCertificateRequest.switch_ids:type_name -> forge.SwitchIdList + 908, // 1106: forge.ComponentConfigureSwitchCertificateResponse.results:type_name -> forge.ComponentResult + 908, // 1107: forge.FirmwareUpdateStatus.result:type_name -> forge.ComponentResult + 77, // 1108: forge.FirmwareUpdateStatus.state:type_name -> forge.FirmwareUpdateState + 1019, // 1109: forge.FirmwareUpdateStatus.updated_at:type_name -> google.protobuf.Timestamp + 1079, // 1110: forge.UpdateComputeTrayFirmwareTarget.machine_ids:type_name -> common.MachineIdList + 80, // 1111: forge.UpdateComputeTrayFirmwareTarget.components:type_name -> forge.ComputeTrayComponent + 909, // 1112: forge.UpdateSwitchFirmwareTarget.switch_ids:type_name -> forge.SwitchIdList + 78, // 1113: forge.UpdateSwitchFirmwareTarget.components:type_name -> forge.NvSwitchComponent + 910, // 1114: forge.UpdatePowerShelfFirmwareTarget.power_shelf_ids:type_name -> forge.PowerShelfIdList + 79, // 1115: forge.UpdatePowerShelfFirmwareTarget.components:type_name -> forge.PowerShelfComponent + 757, // 1116: forge.UpdateFirmwareObjectTarget.rack_ids:type_name -> forge.RackIdList + 919, // 1117: forge.UpdateComponentFirmwareRequest.compute_trays:type_name -> forge.UpdateComputeTrayFirmwareTarget + 920, // 1118: forge.UpdateComponentFirmwareRequest.switches:type_name -> forge.UpdateSwitchFirmwareTarget + 921, // 1119: forge.UpdateComponentFirmwareRequest.power_shelves:type_name -> forge.UpdatePowerShelfFirmwareTarget + 922, // 1120: forge.UpdateComponentFirmwareRequest.racks:type_name -> forge.UpdateFirmwareObjectTarget + 908, // 1121: forge.UpdateComponentFirmwareResponse.results:type_name -> forge.ComponentResult + 1079, // 1122: forge.GetComponentFirmwareStatusRequest.machine_ids:type_name -> common.MachineIdList + 909, // 1123: forge.GetComponentFirmwareStatusRequest.switch_ids:type_name -> forge.SwitchIdList + 910, // 1124: forge.GetComponentFirmwareStatusRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList + 757, // 1125: forge.GetComponentFirmwareStatusRequest.rack_ids:type_name -> forge.RackIdList + 918, // 1126: forge.GetComponentFirmwareStatusResponse.statuses:type_name -> forge.FirmwareUpdateStatus + 1079, // 1127: forge.ListComponentFirmwareVersionsRequest.machine_ids:type_name -> common.MachineIdList + 909, // 1128: forge.ListComponentFirmwareVersionsRequest.switch_ids:type_name -> forge.SwitchIdList + 910, // 1129: forge.ListComponentFirmwareVersionsRequest.power_shelf_ids:type_name -> forge.PowerShelfIdList + 757, // 1130: forge.ListComponentFirmwareVersionsRequest.rack_ids:type_name -> forge.RackIdList + 80, // 1131: forge.ComputeTrayFirmwareVersions.component:type_name -> forge.ComputeTrayComponent + 908, // 1132: forge.DeviceFirmwareVersions.result:type_name -> forge.ComponentResult + 928, // 1133: forge.DeviceFirmwareVersions.compute_fw_versions:type_name -> forge.ComputeTrayFirmwareVersions + 929, // 1134: forge.ListComponentFirmwareVersionsResponse.devices:type_name -> forge.DeviceFirmwareVersions + 273, // 1135: forge.SpxPartitionCreationRequest.metadata:type_name -> forge.Metadata + 1039, // 1136: forge.SpxPartitionCreationRequest.id:type_name -> common.SpxPartitionId + 273, // 1137: forge.SpxPartition.metadata:type_name -> forge.Metadata + 1039, // 1138: forge.SpxPartition.id:type_name -> common.SpxPartitionId + 1039, // 1139: forge.SpxPartitionIdList.spx_partition_ids:type_name -> common.SpxPartitionId + 1039, // 1140: forge.SpxPartitionDeletionRequest.id:type_name -> common.SpxPartitionId + 272, // 1141: forge.SpxPartitionSearchFilter.label:type_name -> forge.Label + 932, // 1142: forge.SpxPartitionList.spx_partitions:type_name -> forge.SpxPartition + 1039, // 1143: forge.SpxPartitionsByIdsRequest.spx_partition_ids:type_name -> common.SpxPartitionId + 1031, // 1144: forge.AdminForceDeleteSwitchRequest.switch_id:type_name -> common.SwitchId + 1028, // 1145: forge.AdminForceDeletePowerShelfRequest.power_shelf_id:type_name -> common.PowerShelfId + 1038, // 1146: forge.OperatingSystem.id:type_name -> common.OperatingSystemId + 81, // 1147: forge.OperatingSystem.type:type_name -> forge.OperatingSystemType + 8, // 1148: forge.OperatingSystem.status:type_name -> forge.TenantState + 1037, // 1149: forge.OperatingSystem.ipxe_template_id:type_name -> common.IpxeTemplateId + 280, // 1150: forge.OperatingSystem.ipxe_template_parameters:type_name -> forge.IpxeTemplateParameter + 281, // 1151: forge.OperatingSystem.ipxe_template_artifacts:type_name -> forge.IpxeTemplateArtifact + 1038, // 1152: forge.CreateOperatingSystemRequest.id:type_name -> common.OperatingSystemId + 1037, // 1153: forge.CreateOperatingSystemRequest.ipxe_template_id:type_name -> common.IpxeTemplateId + 280, // 1154: forge.CreateOperatingSystemRequest.ipxe_template_parameters:type_name -> forge.IpxeTemplateParameter + 281, // 1155: forge.CreateOperatingSystemRequest.ipxe_template_artifacts:type_name -> forge.IpxeTemplateArtifact + 280, // 1156: forge.IpxeTemplateParameters.items:type_name -> forge.IpxeTemplateParameter + 281, // 1157: forge.IpxeTemplateArtifacts.items:type_name -> forge.IpxeTemplateArtifact + 1038, // 1158: forge.UpdateOperatingSystemRequest.id:type_name -> common.OperatingSystemId + 1037, // 1159: forge.UpdateOperatingSystemRequest.ipxe_template_id:type_name -> common.IpxeTemplateId + 945, // 1160: forge.UpdateOperatingSystemRequest.ipxe_template_parameters:type_name -> forge.IpxeTemplateParameters + 946, // 1161: forge.UpdateOperatingSystemRequest.ipxe_template_artifacts:type_name -> forge.IpxeTemplateArtifacts + 1038, // 1162: forge.DeleteOperatingSystemRequest.id:type_name -> common.OperatingSystemId + 1038, // 1163: forge.OperatingSystemIdList.ids:type_name -> common.OperatingSystemId + 1038, // 1164: forge.OperatingSystemsByIdsRequest.ids:type_name -> common.OperatingSystemId + 943, // 1165: forge.OperatingSystemList.operating_systems:type_name -> forge.OperatingSystem + 1038, // 1166: forge.GetOperatingSystemCachableIpxeTemplateArtifactsRequest.id:type_name -> common.OperatingSystemId + 281, // 1167: forge.IpxeTemplateArtifactList.artifacts:type_name -> forge.IpxeTemplateArtifact + 1038, // 1168: forge.UpdateOperatingSystemIpxeTemplateArtifactRequest.id:type_name -> common.OperatingSystemId + 956, // 1169: forge.UpdateOperatingSystemIpxeTemplateArtifactRequest.updates:type_name -> forge.IpxeTemplateArtifactUpdateRequest + 1018, // 1170: forge.GetMachineBootInterfacesRequest.machine_id:type_name -> common.MachineId + 1041, // 1171: forge.MachineInterfaceBootInterface.interface_id:type_name -> common.MachineInterfaceId + 1019, // 1172: forge.RetainedBootInterface.recorded_at:type_name -> google.protobuf.Timestamp + 1018, // 1173: forge.GetMachineBootInterfacesResponse.machine_id:type_name -> common.MachineId + 963, // 1174: forge.GetMachineBootInterfacesResponse.machine_interfaces:type_name -> forge.MachineInterfaceBootInterface + 964, // 1175: forge.GetMachineBootInterfacesResponse.predicted_interfaces:type_name -> forge.PredictedBootInterface + 965, // 1176: forge.GetMachineBootInterfacesResponse.explored_endpoints:type_name -> forge.ExploredBootInterface + 966, // 1177: forge.GetMachineBootInterfacesResponse.retained_interfaces:type_name -> forge.RetainedBootInterface + 962, // 1178: forge.GetMachineBootInterfacesResponse.default_boot_interface:type_name -> forge.MachineBootInterface + 962, // 1179: forge.GetMachineBootInterfacesResponse.predicted_boot_interface:type_name -> forge.MachineBootInterface + 1017, // 1180: forge.GetMachineBootInterfacesResponse.reconciliation:type_name -> forge.GetMachineBootInterfacesResponse.Reconciliation + 1082, // 1181: forge.SitePrefix.id:type_name -> common.SitePrefixId + 972, // 1182: forge.SitePrefix.config:type_name -> forge.SitePrefixConfig + 973, // 1183: forge.SitePrefix.status:type_name -> forge.SitePrefixStatus + 273, // 1184: forge.SitePrefix.metadata:type_name -> forge.Metadata + 1019, // 1185: forge.SitePrefix.created_at:type_name -> google.protobuf.Timestamp + 1019, // 1186: forge.SitePrefix.updated_at:type_name -> google.protobuf.Timestamp + 85, // 1187: forge.SitePrefixConfig.routing_scope:type_name -> forge.SitePrefixRoutingScope + 84, // 1188: forge.SitePrefixStatus.authority:type_name -> forge.SitePrefixAuthority + 86, // 1189: forge.SitePrefixStatus.lifecycle_state:type_name -> forge.SitePrefixLifecycleState + 84, // 1190: forge.SitePrefixSearchFilter.authority:type_name -> forge.SitePrefixAuthority + 85, // 1191: forge.SitePrefixSearchFilter.routing_scope:type_name -> forge.SitePrefixRoutingScope + 86, // 1192: forge.SitePrefixSearchFilter.lifecycle_state:type_name -> forge.SitePrefixLifecycleState + 7, // 1193: forge.SitePrefixSearchFilter.prefix_match_type:type_name -> forge.PrefixMatchType + 1082, // 1194: forge.SitePrefixesByIdsRequest.site_prefix_ids:type_name -> common.SitePrefixId + 1082, // 1195: forge.SitePrefixIdList.site_prefix_ids:type_name -> common.SitePrefixId + 971, // 1196: forge.SitePrefixList.site_prefixes:type_name -> forge.SitePrefix + 981, // 1197: forge.DNSMessage.DNSResponse.rrs:type_name -> forge.DNSMessage.DNSResponse.DNSRR + 238, // 1198: forge.StateHistories.HistoriesEntry.value:type_name -> forge.StateHistoryRecords + 329, // 1199: forge.MachineStateHistories.HistoriesEntry.value:type_name -> forge.MachineStateHistoryRecords + 332, // 1200: forge.HealthHistories.HistoriesEntry.value:type_name -> forge.HealthHistoryRecords + 958, // 1201: forge.TrafficInterceptBridging.HostRepresentorInterceptBridgingEntry.value:type_name -> forge.HostRepresentorInterceptBridging + 89, // 1202: forge.MachineCredentialsUpdateRequest.Credentials.credential_purpose:type_name -> forge.MachineCredentialsUpdateRequest.CredentialPurpose + 1006, // 1203: forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo.pair:type_name -> forge.ForgeAgentControlResponse.ForgeAgentControlExtraInfo.KeyValuePair + 1047, // 1204: forge.ForgeAgentControlResponse.MachineValidation.validation_id:type_name -> common.MachineValidationId + 997, // 1205: forge.ForgeAgentControlResponse.MachineValidation.filter:type_name -> forge.ForgeAgentControlResponse.MachineValidationFilter + 1044, // 1206: forge.ForgeAgentControlResponse.MachineValidationFilter.contexts:type_name -> common.StringList + 999, // 1207: forge.ForgeAgentControlResponse.MlxAction.device_actions:type_name -> forge.ForgeAgentControlResponse.MlxDeviceAction + 1000, // 1208: forge.ForgeAgentControlResponse.MlxDeviceAction.noop:type_name -> forge.ForgeAgentControlResponse.MlxDeviceNoop + 1001, // 1209: forge.ForgeAgentControlResponse.MlxDeviceAction.lock:type_name -> forge.ForgeAgentControlResponse.MlxDeviceLock + 1002, // 1210: forge.ForgeAgentControlResponse.MlxDeviceAction.unlock:type_name -> forge.ForgeAgentControlResponse.MlxDeviceUnlock + 1003, // 1211: forge.ForgeAgentControlResponse.MlxDeviceAction.apply_profile:type_name -> forge.ForgeAgentControlResponse.MlxDeviceApplyProfile + 1004, // 1212: forge.ForgeAgentControlResponse.MlxDeviceAction.apply_firmware:type_name -> forge.ForgeAgentControlResponse.MlxDeviceApplyFirmware + 1083, // 1213: forge.ForgeAgentControlResponse.MlxDeviceApplyProfile.serialized_profile:type_name -> mlx_device.SerializableMlxConfigProfile + 1084, // 1214: forge.ForgeAgentControlResponse.MlxDeviceApplyFirmware.profile:type_name -> mlx_device.FirmwareFlasherProfile + 1085, // 1215: forge.ForgeAgentControlResponse.FirmwareUpgrade.task:type_name -> scout_firmware_upgrade.ScoutFirmwareUpgradeTask + 91, // 1216: forge.MachineCleanupInfo.CleanupStepResult.result:type_name -> forge.MachineCleanupInfo.CleanupResult + 1018, // 1217: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem.id:type_name -> common.MachineId + 1019, // 1218: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem.requested_at:type_name -> google.protobuf.Timestamp + 1019, // 1219: forge.DpuReprovisioningListResponse.DpuReprovisioningListItem.initiated_at:type_name -> google.protobuf.Timestamp + 1018, // 1220: forge.HostReprovisioningListResponse.HostReprovisioningListItem.id:type_name -> common.MachineId + 1019, // 1221: forge.HostReprovisioningListResponse.HostReprovisioningListItem.requested_at:type_name -> google.protobuf.Timestamp + 1019, // 1222: forge.HostReprovisioningListResponse.HostReprovisioningListItem.initiated_at:type_name -> google.protobuf.Timestamp + 1018, // 1223: forge.DPFStateResponse.DPFState.machine_id:type_name -> common.MachineId + 962, // 1224: forge.GetMachineBootInterfacesResponse.Reconciliation.desired_boot_interface:type_name -> forge.MachineBootInterface + 1019, // 1225: forge.GetMachineBootInterfacesResponse.Reconciliation.observed_at:type_name -> google.protobuf.Timestamp + 100, // 1226: forge.GetMachineBootInterfacesResponse.Reconciliation.reconciliation_state:type_name -> forge.GetMachineBootInterfacesResponse.Reconciliation.State + 149, // 1227: forge.Forge.Version:input_type -> forge.VersionRequest + 1086, // 1228: forge.Forge.CreateDomain:input_type -> dns.CreateDomainRequest + 1087, // 1229: forge.Forge.UpdateDomain:input_type -> dns.UpdateDomainRequest + 1088, // 1230: forge.Forge.DeleteDomain:input_type -> dns.DomainDeletionRequest + 1089, // 1231: forge.Forge.FindDomain:input_type -> dns.DomainSearchQuery + 891, // 1232: forge.Forge.CreateDomainLegacy:input_type -> forge.DomainLegacy + 891, // 1233: forge.Forge.UpdateDomainLegacy:input_type -> forge.DomainLegacy + 893, // 1234: forge.Forge.DeleteDomainLegacy:input_type -> forge.DomainDeletionLegacy + 895, // 1235: forge.Forge.FindDomainLegacy:input_type -> forge.DomainSearchQueryLegacy + 171, // 1236: forge.Forge.CreateVpc:input_type -> forge.VpcCreationRequest + 172, // 1237: forge.Forge.UpdateVpc:input_type -> forge.VpcUpdateRequest + 174, // 1238: forge.Forge.UpdateVpcVirtualization:input_type -> forge.VpcUpdateVirtualizationRequest + 176, // 1239: forge.Forge.DeleteVpc:input_type -> forge.VpcDeletionRequest + 161, // 1240: forge.Forge.FindVpcIds:input_type -> forge.VpcSearchFilter + 163, // 1241: forge.Forge.FindVpcsByIds:input_type -> forge.VpcsByIdsRequest + 931, // 1242: forge.Forge.CreateSpxPartition:input_type -> forge.SpxPartitionCreationRequest + 934, // 1243: forge.Forge.DeleteSpxPartition:input_type -> forge.SpxPartitionDeletionRequest + 936, // 1244: forge.Forge.FindSpxPartitionIds:input_type -> forge.SpxPartitionSearchFilter + 938, // 1245: forge.Forge.FindSpxPartitionsByIds:input_type -> forge.SpxPartitionsByIdsRequest + 182, // 1246: forge.Forge.CreateVpcPrefix:input_type -> forge.VpcPrefixCreationRequest + 183, // 1247: forge.Forge.SearchVpcPrefixes:input_type -> forge.VpcPrefixSearchQuery + 184, // 1248: forge.Forge.GetVpcPrefixes:input_type -> forge.VpcPrefixGetRequest + 187, // 1249: forge.Forge.UpdateVpcPrefix:input_type -> forge.VpcPrefixUpdateRequest + 188, // 1250: forge.Forge.DeleteVpcPrefix:input_type -> forge.VpcPrefixDeletionRequest + 974, // 1251: forge.Forge.FindSitePrefixIds:input_type -> forge.SitePrefixSearchFilter + 975, // 1252: forge.Forge.FindSitePrefixesByIds:input_type -> forge.SitePrefixesByIdsRequest + 194, // 1253: forge.Forge.CreateVpcPeering:input_type -> forge.VpcPeeringCreationRequest + 195, // 1254: forge.Forge.FindVpcPeeringIds:input_type -> forge.VpcPeeringSearchFilter + 196, // 1255: forge.Forge.FindVpcPeeringsByIds:input_type -> forge.VpcPeeringsByIdsRequest + 197, // 1256: forge.Forge.DeleteVpcPeering:input_type -> forge.VpcPeeringDeletionRequest + 264, // 1257: forge.Forge.FindNetworkSegmentIds:input_type -> forge.NetworkSegmentSearchFilter + 266, // 1258: forge.Forge.FindNetworkSegmentsByIds:input_type -> forge.NetworkSegmentsByIdsRequest + 258, // 1259: forge.Forge.CreateNetworkSegment:input_type -> forge.NetworkSegmentCreationRequest + 260, // 1260: forge.Forge.AttachNetworkSegmentToVpc:input_type -> forge.AttachNetworkSegmentToVpcRequest + 259, // 1261: forge.Forge.DeleteNetworkSegment:input_type -> forge.NetworkSegmentDeletionRequest + 160, // 1262: forge.Forge.NetworkSegmentsForVpc:input_type -> forge.VpcSearchQuery + 207, // 1263: forge.Forge.FindIBPartitionIds:input_type -> forge.IBPartitionSearchFilter + 208, // 1264: forge.Forge.FindIBPartitionsByIds:input_type -> forge.IBPartitionsByIdsRequest + 203, // 1265: forge.Forge.CreateIBPartition:input_type -> forge.IBPartitionCreationRequest + 204, // 1266: forge.Forge.UpdateIBPartition:input_type -> forge.IBPartitionUpdateRequest + 205, // 1267: forge.Forge.DeleteIBPartition:input_type -> forge.IBPartitionDeletionRequest + 164, // 1268: forge.Forge.IBPartitionsForTenant:input_type -> forge.TenantSearchQuery + 219, // 1269: forge.Forge.FindPowerShelves:input_type -> forge.PowerShelfQuery + 220, // 1270: forge.Forge.FindPowerShelfIds:input_type -> forge.PowerShelfSearchFilter + 221, // 1271: forge.Forge.FindPowerShelvesByIds:input_type -> forge.PowerShelvesByIdsRequest + 215, // 1272: forge.Forge.DeletePowerShelf:input_type -> forge.PowerShelfDeletionRequest + 941, // 1273: forge.Forge.AdminForceDeletePowerShelf:input_type -> forge.AdminForceDeletePowerShelfRequest + 217, // 1274: forge.Forge.SetPowerShelfMaintenance:input_type -> forge.PowerShelfMaintenanceRequest + 241, // 1275: forge.Forge.FindSwitches:input_type -> forge.SwitchQuery + 242, // 1276: forge.Forge.FindSwitchIds:input_type -> forge.SwitchSearchFilter + 243, // 1277: forge.Forge.FindSwitchesByIds:input_type -> forge.SwitchesByIdsRequest + 235, // 1278: forge.Forge.DeleteSwitch:input_type -> forge.SwitchDeletionRequest + 939, // 1279: forge.Forge.AdminForceDeleteSwitch:input_type -> forge.AdminForceDeleteSwitchRequest + 252, // 1280: forge.Forge.FindIBFabricIds:input_type -> forge.IBFabricSearchFilter + 277, // 1281: forge.Forge.AllocateInstance:input_type -> forge.InstanceAllocationRequest + 278, // 1282: forge.Forge.AllocateInstances:input_type -> forge.BatchInstanceAllocationRequest + 323, // 1283: forge.Forge.ReleaseInstance:input_type -> forge.InstanceReleaseRequest + 295, // 1284: forge.Forge.UpdateInstanceOperatingSystem:input_type -> forge.InstanceOperatingSystemUpdateRequest + 296, // 1285: forge.Forge.UpdateInstanceConfig:input_type -> forge.InstanceConfigUpdateRequest + 274, // 1286: forge.Forge.FindInstanceIds:input_type -> forge.InstanceSearchFilter + 276, // 1287: forge.Forge.FindInstancesByIds:input_type -> forge.InstancesByIdsRequest + 1018, // 1288: forge.Forge.FindInstanceByMachineID:input_type -> common.MachineId + 396, // 1289: forge.Forge.GetManagedHostNetworkConfig:input_type -> forge.ManagedHostNetworkConfigRequest + 461, // 1290: forge.Forge.RecordDpuNetworkStatus:input_type -> forge.DpuNetworkStatus + 1018, // 1291: forge.Forge.ListMachineHealthReports:input_type -> common.MachineId + 467, // 1292: forge.Forge.InsertMachineHealthReport:input_type -> forge.InsertMachineHealthReportRequest + 478, // 1293: forge.Forge.RemoveMachineHealthReport:input_type -> forge.RemoveMachineHealthReportRequest + 470, // 1294: forge.Forge.ListRackHealthReports:input_type -> forge.ListRackHealthReportsRequest + 468, // 1295: forge.Forge.InsertRackHealthReport:input_type -> forge.InsertRackHealthReportRequest + 469, // 1296: forge.Forge.RemoveRackHealthReport:input_type -> forge.RemoveRackHealthReportRequest + 473, // 1297: forge.Forge.ListSwitchHealthReports:input_type -> forge.ListSwitchHealthReportsRequest + 471, // 1298: forge.Forge.InsertSwitchHealthReport:input_type -> forge.InsertSwitchHealthReportRequest + 472, // 1299: forge.Forge.RemoveSwitchHealthReport:input_type -> forge.RemoveSwitchHealthReportRequest + 476, // 1300: forge.Forge.ListPowerShelfHealthReports:input_type -> forge.ListPowerShelfHealthReportsRequest + 474, // 1301: forge.Forge.InsertPowerShelfHealthReport:input_type -> forge.InsertPowerShelfHealthReportRequest + 475, // 1302: forge.Forge.RemovePowerShelfHealthReport:input_type -> forge.RemovePowerShelfHealthReportRequest + 479, // 1303: forge.Forge.ListNVLinkDomainHealthReports:input_type -> forge.ListNVLinkDomainHealthReportsRequest + 480, // 1304: forge.Forge.InsertNVLinkDomainHealthReport:input_type -> forge.InsertNVLinkDomainHealthReportRequest + 481, // 1305: forge.Forge.RemoveNVLinkDomainHealthReport:input_type -> forge.RemoveNVLinkDomainHealthReportRequest + 1018, // 1306: forge.Forge.ListHealthReportOverrides:input_type -> common.MachineId + 467, // 1307: forge.Forge.InsertHealthReportOverride:input_type -> forge.InsertMachineHealthReportRequest + 478, // 1308: forge.Forge.RemoveHealthReportOverride:input_type -> forge.RemoveMachineHealthReportRequest + 415, // 1309: forge.Forge.DpuAgentUpgradeCheck:input_type -> forge.DpuAgentUpgradeCheckRequest + 417, // 1310: forge.Forge.DpuAgentUpgradePolicyAction:input_type -> forge.DpuAgentUpgradePolicyRequest + 1090, // 1311: forge.Forge.LookupRecord:input_type -> dns.DnsResourceRecordLookupRequest + 1091, // 1312: forge.Forge.GetAllDomains:input_type -> dns.GetAllDomainsRequest + 1092, // 1313: forge.Forge.GetAllDomainMetadata:input_type -> dns.DomainMetadataRequest + 269, // 1314: forge.Forge.InvokeInstancePower:input_type -> forge.InstancePowerRequest + 442, // 1315: forge.Forge.ForgeAgentControl:input_type -> forge.ForgeAgentControlRequest + 444, // 1316: forge.Forge.DiscoverMachine:input_type -> forge.MachineDiscoveryInfo + 448, // 1317: forge.Forge.RenewMachineCertificate:input_type -> forge.MachineCertificateRenewRequest + 445, // 1318: forge.Forge.DiscoveryCompleted:input_type -> forge.MachineDiscoveryCompletedRequest + 446, // 1319: forge.Forge.CleanupMachineCompleted:input_type -> forge.MachineCleanupInfo + 453, // 1320: forge.Forge.ReportForgeScoutError:input_type -> forge.ForgeScoutErrorReport + 372, // 1321: forge.Forge.DiscoverDhcp:input_type -> forge.DhcpDiscovery + 373, // 1322: forge.Forge.ExpireDhcpLease:input_type -> forge.ExpireDhcpLeaseRequest + 342, // 1323: forge.Forge.AssignStaticAddress:input_type -> forge.AssignStaticAddressRequest + 344, // 1324: forge.Forge.RemoveStaticAddress:input_type -> forge.RemoveStaticAddressRequest + 346, // 1325: forge.Forge.FindInterfaceAddresses:input_type -> forge.FindInterfaceAddressesRequest + 341, // 1326: forge.Forge.FindInterfaces:input_type -> forge.InterfaceSearchQuery + 340, // 1327: forge.Forge.DeleteInterface:input_type -> forge.InterfaceDeleteQuery + 517, // 1328: forge.Forge.FindIpAddress:input_type -> forge.FindIpAddressRequest + 326, // 1329: forge.Forge.FindMachineIds:input_type -> forge.MachineSearchConfig + 325, // 1330: forge.Forge.FindMachinesByIds:input_type -> forge.MachinesByIdsRequest + 327, // 1331: forge.Forge.FindMachineStateHistories:input_type -> forge.MachineStateHistoriesRequest + 330, // 1332: forge.Forge.FindMachineHealthHistories:input_type -> forge.MachineHealthHistoriesRequest + 218, // 1333: forge.Forge.FindPowerShelfStateHistories:input_type -> forge.PowerShelfStateHistoriesRequest + 762, // 1334: forge.Forge.FindRackStateHistories:input_type -> forge.RackStateHistoriesRequest + 239, // 1335: forge.Forge.FindSwitchStateHistories:input_type -> forge.SwitchStateHistoriesRequest + 262, // 1336: forge.Forge.FindNetworkSegmentStateHistories:input_type -> forge.NetworkSegmentStateHistoriesRequest + 190, // 1337: forge.Forge.FindVpcPrefixStateHistories:input_type -> forge.VpcPrefixStateHistoriesRequest + 335, // 1338: forge.Forge.FindTenantOrganizationIds:input_type -> forge.TenantSearchFilter + 334, // 1339: forge.Forge.FindTenantsByOrganizationIds:input_type -> forge.TenantByOrganizationIdsRequest + 1079, // 1340: forge.Forge.FindConnectedDevicesByDpuMachineIds:input_type -> common.MachineIdList + 544, // 1341: forge.Forge.FindMachineIdsByBmcIps:input_type -> forge.BmcIpList + 545, // 1342: forge.Forge.FindMacAddressByBmcIp:input_type -> forge.BmcIp + 521, // 1343: forge.Forge.FindBmcIps:input_type -> forge.FindBmcIpsRequest + 519, // 1344: forge.Forge.IdentifyUuid:input_type -> forge.IdentifyUuidRequest + 522, // 1345: forge.Forge.IdentifyMac:input_type -> forge.IdentifyMacRequest + 524, // 1346: forge.Forge.IdentifySerial:input_type -> forge.IdentifySerialRequest + 438, // 1347: forge.Forge.GetBMCMetaData:input_type -> forge.BMCMetaDataGetRequest + 440, // 1348: forge.Forge.UpdateMachineCredentials:input_type -> forge.MachineCredentialsUpdateRequest + 455, // 1349: forge.Forge.GetPxeInstructions:input_type -> forge.PxeInstructionRequest + 459, // 1350: forge.Forge.GetCloudInitInstructions:input_type -> forge.CloudInitInstructionsRequest + 152, // 1351: forge.Forge.Echo:input_type -> forge.EchoRequest + 486, // 1352: forge.Forge.CreateTenant:input_type -> forge.CreateTenantRequest + 490, // 1353: forge.Forge.FindTenant:input_type -> forge.FindTenantRequest + 488, // 1354: forge.Forge.UpdateTenant:input_type -> forge.UpdateTenantRequest + 496, // 1355: forge.Forge.CreateTenantKeyset:input_type -> forge.CreateTenantKeysetRequest + 503, // 1356: forge.Forge.FindTenantKeysetIds:input_type -> forge.TenantKeysetSearchFilter + 505, // 1357: forge.Forge.FindTenantKeysetsByIds:input_type -> forge.TenantKeysetsByIdsRequest + 499, // 1358: forge.Forge.UpdateTenantKeyset:input_type -> forge.UpdateTenantKeysetRequest + 501, // 1359: forge.Forge.DeleteTenantKeyset:input_type -> forge.DeleteTenantKeysetRequest + 506, // 1360: forge.Forge.ValidateTenantPublicKey:input_type -> forge.ValidateTenantPublicKeyRequest + 379, // 1361: forge.Forge.GetBmcCredentials:input_type -> forge.GetBmcCredentialsRequest + 380, // 1362: forge.Forge.GetSwitchNvosCredentials:input_type -> forge.GetSwitchNvosCredentialsRequest + 413, // 1363: forge.Forge.GetAllManagedHostNetworkStatus:input_type -> forge.ManagedHostNetworkStatusRequest + 383, // 1364: forge.Forge.GetSiteExplorationReport:input_type -> forge.GetSiteExplorationRequest + 1093, // 1365: forge.Forge.GetSiteExplorerLastRun:input_type -> google.protobuf.Empty + 384, // 1366: forge.Forge.ClearSiteExplorationError:input_type -> forge.ClearSiteExplorationErrorRequest + 390, // 1367: forge.Forge.IsBmcInManagedHost:input_type -> forge.BmcEndpointRequest + 390, // 1368: forge.Forge.BmcCredentialStatus:input_type -> forge.BmcEndpointRequest + 390, // 1369: forge.Forge.Explore:input_type -> forge.BmcEndpointRequest + 385, // 1370: forge.Forge.ReExploreEndpoint:input_type -> forge.ReExploreEndpointRequest + 386, // 1371: forge.Forge.RefreshEndpointReport:input_type -> forge.RefreshEndpointReportRequest + 387, // 1372: forge.Forge.DeleteExploredEndpoint:input_type -> forge.DeleteExploredEndpointRequest + 388, // 1373: forge.Forge.PauseExploredEndpointRemediation:input_type -> forge.PauseExploredEndpointRemediationRequest + 1094, // 1374: forge.Forge.FindExploredEndpointIds:input_type -> site_explorer.ExploredEndpointSearchFilter + 1095, // 1375: forge.Forge.FindExploredEndpointsByIds:input_type -> site_explorer.ExploredEndpointsByIdsRequest + 1096, // 1376: forge.Forge.FindExploredManagedHostIds:input_type -> site_explorer.ExploredManagedHostSearchFilter + 1097, // 1377: forge.Forge.FindExploredManagedHostsByIds:input_type -> site_explorer.ExploredManagedHostsByIdsRequest + 1098, // 1378: forge.Forge.FindExploredMlxDeviceHostIds:input_type -> site_explorer.ExploredMlxDeviceHostSearchFilter + 1099, // 1379: forge.Forge.FindExploredMlxDevicesByIds:input_type -> site_explorer.ExploredMlxDevicesByIdsRequest + 394, // 1380: forge.Forge.UpdateMachineHardwareInfo:input_type -> forge.UpdateMachineHardwareInfoRequest + 419, // 1381: forge.Forge.AdminForceDeleteMachine:input_type -> forge.AdminForceDeleteMachineRequest + 508, // 1382: forge.Forge.AdminListResourcePools:input_type -> forge.ListResourcePoolsRequest + 511, // 1383: forge.Forge.AdminGrowResourcePool:input_type -> forge.GrowResourcePoolRequest + 356, // 1384: forge.Forge.UpdateMachineMetadata:input_type -> forge.MachineMetadataUpdateRequest + 357, // 1385: forge.Forge.UpdateRackMetadata:input_type -> forge.RackMetadataUpdateRequest + 358, // 1386: forge.Forge.UpdateSwitchMetadata:input_type -> forge.SwitchMetadataUpdateRequest + 359, // 1387: forge.Forge.UpdatePowerShelfMetadata:input_type -> forge.PowerShelfMetadataUpdateRequest + 776, // 1388: forge.Forge.UpdateMachineNvLinkInfo:input_type -> forge.UpdateMachineNvLinkInfoRequest + 515, // 1389: forge.Forge.SetMaintenance:input_type -> forge.MaintenanceRequest + 516, // 1390: forge.Forge.SetDynamicConfig:input_type -> forge.SetDynamicConfigRequest + 526, // 1391: forge.Forge.TriggerDpuReprovisioning:input_type -> forge.DpuReprovisioningRequest + 527, // 1392: forge.Forge.ListDpuWaitingForReprovisioning:input_type -> forge.DpuReprovisioningListRequest + 529, // 1393: forge.Forge.TriggerHostReprovisioning:input_type -> forge.HostReprovisioningRequest + 532, // 1394: forge.Forge.ListHostsWaitingForReprovisioning:input_type -> forge.HostReprovisioningListRequest + 530, // 1395: forge.Forge.TriggerBmcCredentialRotation:input_type -> forge.BmcCredentialRotationRequest + 531, // 1396: forge.Forge.TriggerUefiCredentialRotation:input_type -> forge.UefiCredentialRotationRequest + 1018, // 1397: forge.Forge.MarkManualFirmwareUpgradeComplete:input_type -> common.MachineId + 585, // 1398: forge.Forge.ReportScoutFirmwareUpgradeStatus:input_type -> forge.ScoutFirmwareUpgradeStatusRequest + 538, // 1399: forge.Forge.GetDpuInfoList:input_type -> forge.GetDpuInfoListRequest + 1041, // 1400: forge.Forge.GetMachineBootOverride:input_type -> common.MachineInterfaceId + 541, // 1401: forge.Forge.SetMachineBootOverride:input_type -> forge.MachineBootOverride + 1041, // 1402: forge.Forge.ClearMachineBootOverride:input_type -> common.MachineInterfaceId + 961, // 1403: forge.Forge.GetMachineBootInterfaces:input_type -> forge.GetMachineBootInterfacesRequest + 550, // 1404: forge.Forge.GetNetworkTopology:input_type -> forge.NetworkTopologyRequest + 551, // 1405: forge.Forge.FindNetworkDevicesByDeviceIds:input_type -> forge.NetworkDeviceIdList + 140, // 1406: forge.Forge.CreateCredential:input_type -> forge.CredentialCreationRequest + 141, // 1407: forge.Forge.DeleteCredential:input_type -> forge.CredentialDeletionRequest + 144, // 1408: forge.Forge.RotateCredential:input_type -> forge.RotateCredentialRequest + 146, // 1409: forge.Forge.GetCredentialRotationStatus:input_type -> forge.CredentialRotationStatusRequest + 968, // 1410: forge.Forge.GetContainerRegistryCredential:input_type -> forge.GetContainerRegistryCredentialRequest + 970, // 1411: forge.Forge.SetContainerRegistryCredential:input_type -> forge.SetContainerRegistryCredentialRequest + 1093, // 1412: forge.Forge.GetRouteServers:input_type -> google.protobuf.Empty + 553, // 1413: forge.Forge.AddRouteServers:input_type -> forge.RouteServers + 553, // 1414: forge.Forge.RemoveRouteServers:input_type -> forge.RouteServers + 553, // 1415: forge.Forge.ReplaceRouteServers:input_type -> forge.RouteServers + 360, // 1416: forge.Forge.UpdateAgentReportedInventory:input_type -> forge.DpuAgentInventoryReport + 318, // 1417: forge.Forge.UpdateInstancePhoneHomeLastContact:input_type -> forge.InstancePhoneHomeLastContactRequest + 556, // 1418: forge.Forge.SetHostUefiPassword:input_type -> forge.SetHostUefiPasswordRequest + 558, // 1419: forge.Forge.ClearHostUefiPassword:input_type -> forge.ClearHostUefiPasswordRequest + 560, // 1420: forge.Forge.SetDpuUefiPassword:input_type -> forge.SetDpuUefiPasswordRequest + 573, // 1421: forge.Forge.AddExpectedMachine:input_type -> forge.ExpectedMachine + 574, // 1422: forge.Forge.DeleteExpectedMachine:input_type -> forge.ExpectedMachineRequest + 573, // 1423: forge.Forge.UpdateExpectedMachine:input_type -> forge.ExpectedMachine + 574, // 1424: forge.Forge.GetExpectedMachine:input_type -> forge.ExpectedMachineRequest + 1093, // 1425: forge.Forge.GetAllExpectedMachines:input_type -> google.protobuf.Empty + 575, // 1426: forge.Forge.ReplaceAllExpectedMachines:input_type -> forge.ExpectedMachineList + 1093, // 1427: forge.Forge.DeleteAllExpectedMachines:input_type -> google.protobuf.Empty + 1093, // 1428: forge.Forge.GetAllExpectedMachinesLinked:input_type -> google.protobuf.Empty + 1093, // 1429: forge.Forge.GetAllUnexpectedMachines:input_type -> google.protobuf.Empty + 580, // 1430: forge.Forge.CreateExpectedMachines:input_type -> forge.BatchExpectedMachineOperationRequest + 580, // 1431: forge.Forge.UpdateExpectedMachines:input_type -> forge.BatchExpectedMachineOperationRequest + 222, // 1432: forge.Forge.AddExpectedPowerShelf:input_type -> forge.ExpectedPowerShelf + 223, // 1433: forge.Forge.DeleteExpectedPowerShelf:input_type -> forge.ExpectedPowerShelfRequest + 222, // 1434: forge.Forge.UpdateExpectedPowerShelf:input_type -> forge.ExpectedPowerShelf + 223, // 1435: forge.Forge.GetExpectedPowerShelf:input_type -> forge.ExpectedPowerShelfRequest + 1093, // 1436: forge.Forge.GetAllExpectedPowerShelves:input_type -> google.protobuf.Empty + 224, // 1437: forge.Forge.ReplaceAllExpectedPowerShelves:input_type -> forge.ExpectedPowerShelfList + 1093, // 1438: forge.Forge.DeleteAllExpectedPowerShelves:input_type -> google.protobuf.Empty + 1093, // 1439: forge.Forge.GetAllExpectedPowerShelvesLinked:input_type -> google.protobuf.Empty + 244, // 1440: forge.Forge.AddExpectedSwitch:input_type -> forge.ExpectedSwitch + 245, // 1441: forge.Forge.DeleteExpectedSwitch:input_type -> forge.ExpectedSwitchRequest + 244, // 1442: forge.Forge.UpdateExpectedSwitch:input_type -> forge.ExpectedSwitch + 245, // 1443: forge.Forge.GetExpectedSwitch:input_type -> forge.ExpectedSwitchRequest + 1093, // 1444: forge.Forge.GetAllExpectedSwitches:input_type -> google.protobuf.Empty + 246, // 1445: forge.Forge.ReplaceAllExpectedSwitches:input_type -> forge.ExpectedSwitchList + 1093, // 1446: forge.Forge.DeleteAllExpectedSwitches:input_type -> google.protobuf.Empty + 1093, // 1447: forge.Forge.GetAllExpectedSwitchesLinked:input_type -> google.protobuf.Empty + 249, // 1448: forge.Forge.AddExpectedRack:input_type -> forge.ExpectedRack + 250, // 1449: forge.Forge.DeleteExpectedRack:input_type -> forge.ExpectedRackRequest + 249, // 1450: forge.Forge.UpdateExpectedRack:input_type -> forge.ExpectedRack + 250, // 1451: forge.Forge.GetExpectedRack:input_type -> forge.ExpectedRackRequest + 1093, // 1452: forge.Forge.GetAllExpectedRacks:input_type -> google.protobuf.Empty + 251, // 1453: forge.Forge.ReplaceAllExpectedRacks:input_type -> forge.ExpectedRackList + 1093, // 1454: forge.Forge.DeleteAllExpectedRacks:input_type -> google.protobuf.Empty + 138, // 1455: forge.Forge.AttestQuote:input_type -> forge.AttestQuoteRequest + 655, // 1456: forge.Forge.CreateInstanceType:input_type -> forge.CreateInstanceTypeRequest + 657, // 1457: forge.Forge.FindInstanceTypeIds:input_type -> forge.FindInstanceTypeIdsRequest + 659, // 1458: forge.Forge.FindInstanceTypesByIds:input_type -> forge.FindInstanceTypesByIdsRequest + 664, // 1459: forge.Forge.UpdateInstanceType:input_type -> forge.UpdateInstanceTypeRequest + 661, // 1460: forge.Forge.DeleteInstanceType:input_type -> forge.DeleteInstanceTypeRequest + 665, // 1461: forge.Forge.AssociateMachinesWithInstanceType:input_type -> forge.AssociateMachinesWithInstanceTypeRequest + 667, // 1462: forge.Forge.RemoveMachineInstanceTypeAssociation:input_type -> forge.RemoveMachineInstanceTypeAssociationRequest + 1100, // 1463: forge.Forge.CreateMeasurementBundle:input_type -> measured_boot.CreateMeasurementBundleRequest + 1101, // 1464: forge.Forge.DeleteMeasurementBundle:input_type -> measured_boot.DeleteMeasurementBundleRequest + 1102, // 1465: forge.Forge.RenameMeasurementBundle:input_type -> measured_boot.RenameMeasurementBundleRequest + 1103, // 1466: forge.Forge.UpdateMeasurementBundle:input_type -> measured_boot.UpdateMeasurementBundleRequest + 1104, // 1467: forge.Forge.ShowMeasurementBundle:input_type -> measured_boot.ShowMeasurementBundleRequest + 1105, // 1468: forge.Forge.ShowMeasurementBundles:input_type -> measured_boot.ShowMeasurementBundlesRequest + 1106, // 1469: forge.Forge.ListMeasurementBundles:input_type -> measured_boot.ListMeasurementBundlesRequest + 1107, // 1470: forge.Forge.ListMeasurementBundleMachines:input_type -> measured_boot.ListMeasurementBundleMachinesRequest + 1108, // 1471: forge.Forge.FindClosestBundleMatch:input_type -> measured_boot.FindClosestBundleMatchRequest + 1109, // 1472: forge.Forge.DeleteMeasurementJournal:input_type -> measured_boot.DeleteMeasurementJournalRequest + 1110, // 1473: forge.Forge.ShowMeasurementJournal:input_type -> measured_boot.ShowMeasurementJournalRequest + 1111, // 1474: forge.Forge.ShowMeasurementJournals:input_type -> measured_boot.ShowMeasurementJournalsRequest + 1112, // 1475: forge.Forge.ListMeasurementJournal:input_type -> measured_boot.ListMeasurementJournalRequest + 1113, // 1476: forge.Forge.AttestCandidateMachine:input_type -> measured_boot.AttestCandidateMachineRequest + 1114, // 1477: forge.Forge.ShowCandidateMachine:input_type -> measured_boot.ShowCandidateMachineRequest + 1115, // 1478: forge.Forge.ShowCandidateMachines:input_type -> measured_boot.ShowCandidateMachinesRequest + 1116, // 1479: forge.Forge.ListCandidateMachines:input_type -> measured_boot.ListCandidateMachinesRequest + 1117, // 1480: forge.Forge.CreateMeasurementSystemProfile:input_type -> measured_boot.CreateMeasurementSystemProfileRequest + 1118, // 1481: forge.Forge.DeleteMeasurementSystemProfile:input_type -> measured_boot.DeleteMeasurementSystemProfileRequest + 1119, // 1482: forge.Forge.RenameMeasurementSystemProfile:input_type -> measured_boot.RenameMeasurementSystemProfileRequest + 1120, // 1483: forge.Forge.ShowMeasurementSystemProfile:input_type -> measured_boot.ShowMeasurementSystemProfileRequest + 1121, // 1484: forge.Forge.ShowMeasurementSystemProfiles:input_type -> measured_boot.ShowMeasurementSystemProfilesRequest + 1122, // 1485: forge.Forge.ListMeasurementSystemProfiles:input_type -> measured_boot.ListMeasurementSystemProfilesRequest + 1123, // 1486: forge.Forge.ListMeasurementSystemProfileBundles:input_type -> measured_boot.ListMeasurementSystemProfileBundlesRequest + 1124, // 1487: forge.Forge.ListMeasurementSystemProfileMachines:input_type -> measured_boot.ListMeasurementSystemProfileMachinesRequest + 1125, // 1488: forge.Forge.CreateMeasurementReport:input_type -> measured_boot.CreateMeasurementReportRequest + 1126, // 1489: forge.Forge.DeleteMeasurementReport:input_type -> measured_boot.DeleteMeasurementReportRequest + 1127, // 1490: forge.Forge.PromoteMeasurementReport:input_type -> measured_boot.PromoteMeasurementReportRequest + 1128, // 1491: forge.Forge.RevokeMeasurementReport:input_type -> measured_boot.RevokeMeasurementReportRequest + 1129, // 1492: forge.Forge.ShowMeasurementReportForId:input_type -> measured_boot.ShowMeasurementReportForIdRequest + 1130, // 1493: forge.Forge.ShowMeasurementReportsForMachine:input_type -> measured_boot.ShowMeasurementReportsForMachineRequest + 1131, // 1494: forge.Forge.ShowMeasurementReports:input_type -> measured_boot.ShowMeasurementReportsRequest + 1132, // 1495: forge.Forge.ListMeasurementReport:input_type -> measured_boot.ListMeasurementReportRequest + 1133, // 1496: forge.Forge.MatchMeasurementReport:input_type -> measured_boot.MatchMeasurementReportRequest + 1134, // 1497: forge.Forge.ImportSiteMeasurements:input_type -> measured_boot.ImportSiteMeasurementsRequest + 1135, // 1498: forge.Forge.ExportSiteMeasurements:input_type -> measured_boot.ExportSiteMeasurementsRequest + 1136, // 1499: forge.Forge.AddMeasurementTrustedMachine:input_type -> measured_boot.AddMeasurementTrustedMachineRequest + 1137, // 1500: forge.Forge.RemoveMeasurementTrustedMachine:input_type -> measured_boot.RemoveMeasurementTrustedMachineRequest + 1138, // 1501: forge.Forge.AddMeasurementTrustedProfile:input_type -> measured_boot.AddMeasurementTrustedProfileRequest + 1139, // 1502: forge.Forge.RemoveMeasurementTrustedProfile:input_type -> measured_boot.RemoveMeasurementTrustedProfileRequest + 1140, // 1503: forge.Forge.ListMeasurementTrustedMachines:input_type -> measured_boot.ListMeasurementTrustedMachinesRequest + 1141, // 1504: forge.Forge.ListMeasurementTrustedProfiles:input_type -> measured_boot.ListMeasurementTrustedProfilesRequest + 1142, // 1505: forge.Forge.ListAttestationSummary:input_type -> measured_boot.ListAttestationSummaryRequest + 686, // 1506: forge.Forge.CreateNetworkSecurityGroup:input_type -> forge.CreateNetworkSecurityGroupRequest + 688, // 1507: forge.Forge.FindNetworkSecurityGroupIds:input_type -> forge.FindNetworkSecurityGroupIdsRequest + 690, // 1508: forge.Forge.FindNetworkSecurityGroupsByIds:input_type -> forge.FindNetworkSecurityGroupsByIdsRequest + 693, // 1509: forge.Forge.UpdateNetworkSecurityGroup:input_type -> forge.UpdateNetworkSecurityGroupRequest + 694, // 1510: forge.Forge.DeleteNetworkSecurityGroup:input_type -> forge.DeleteNetworkSecurityGroupRequest + 700, // 1511: forge.Forge.GetNetworkSecurityGroupPropagationStatus:input_type -> forge.GetNetworkSecurityGroupPropagationStatusRequest + 703, // 1512: forge.Forge.GetNetworkSecurityGroupAttachments:input_type -> forge.GetNetworkSecurityGroupAttachmentsRequest + 562, // 1513: forge.Forge.CreateOsImage:input_type -> forge.OsImageAttributes + 566, // 1514: forge.Forge.DeleteOsImage:input_type -> forge.DeleteOsImageRequest + 564, // 1515: forge.Forge.ListOsImage:input_type -> forge.ListOsImageRequest + 1030, // 1516: forge.Forge.GetOsImage:input_type -> common.UUID + 562, // 1517: forge.Forge.UpdateOsImage:input_type -> forge.OsImageAttributes + 568, // 1518: forge.Forge.GetIpxeTemplate:input_type -> forge.GetIpxeTemplateRequest + 569, // 1519: forge.Forge.ListIpxeTemplates:input_type -> forge.ListIpxeTemplatesRequest + 584, // 1520: forge.Forge.RebootCompleted:input_type -> forge.MachineRebootCompletedRequest + 589, // 1521: forge.Forge.PersistValidationResult:input_type -> forge.MachineValidationResultPostRequest + 591, // 1522: forge.Forge.GetMachineValidationResults:input_type -> forge.MachineValidationGetRequest + 586, // 1523: forge.Forge.MachineValidationCompleted:input_type -> forge.MachineValidationCompletedRequest + 594, // 1524: forge.Forge.MachineSetAutoUpdate:input_type -> forge.MachineSetAutoUpdateRequest + 596, // 1525: forge.Forge.GetMachineValidationExternalConfig:input_type -> forge.GetMachineValidationExternalConfigRequest + 599, // 1526: forge.Forge.GetMachineValidationExternalConfigs:input_type -> forge.GetMachineValidationExternalConfigsRequest + 601, // 1527: forge.Forge.AddUpdateMachineValidationExternalConfig:input_type -> forge.AddUpdateMachineValidationExternalConfigRequest + 618, // 1528: forge.Forge.GetMachineValidationRuns:input_type -> forge.MachineValidationRunListGetRequest + 619, // 1529: forge.Forge.FindMachineValidationRunItemIds:input_type -> forge.MachineValidationRunItemSearchFilter + 621, // 1530: forge.Forge.FindMachineValidationRunItemsByIds:input_type -> forge.MachineValidationRunItemsByIdsRequest + 624, // 1531: forge.Forge.GetMachineValidationAttempt:input_type -> forge.MachineValidationAttemptGetRequest + 626, // 1532: forge.Forge.HeartbeatMachineValidationRun:input_type -> forge.MachineValidationHeartbeatRequest + 602, // 1533: forge.Forge.RemoveMachineValidationExternalConfig:input_type -> forge.RemoveMachineValidationExternalConfigRequest + 630, // 1534: forge.Forge.GetMachineValidationTests:input_type -> forge.MachineValidationTestsGetRequest + 632, // 1535: forge.Forge.AddMachineValidationTest:input_type -> forge.MachineValidationTestAddRequest + 631, // 1536: forge.Forge.UpdateMachineValidationTest:input_type -> forge.MachineValidationTestUpdateRequest + 635, // 1537: forge.Forge.MachineValidationTestVerfied:input_type -> forge.MachineValidationTestVerfiedRequest + 639, // 1538: forge.Forge.MachineValidationTestNextVersion:input_type -> forge.MachineValidationTestNextVersionRequest + 640, // 1539: forge.Forge.MachineValidationTestEnableDisableTest:input_type -> forge.MachineValidationTestEnableDisableTestRequest + 642, // 1540: forge.Forge.UpdateMachineValidationRun:input_type -> forge.MachineValidationRunRequest + 432, // 1541: forge.Forge.AdminBmcReset:input_type -> forge.AdminBmcResetRequest + 613, // 1542: forge.Forge.AdminPowerControl:input_type -> forge.AdminPowerControlRequest + 390, // 1543: forge.Forge.DisableSecureBoot:input_type -> forge.BmcEndpointRequest + 422, // 1544: forge.Forge.Lockdown:input_type -> forge.LockdownRequest + 424, // 1545: forge.Forge.LockdownStatus:input_type -> forge.LockdownStatusRequest + 426, // 1546: forge.Forge.MachineSetup:input_type -> forge.MachineSetupRequest + 428, // 1547: forge.Forge.SetDpuFirstBootOrder:input_type -> forge.SetDpuFirstBootOrderRequest + 809, // 1548: forge.Forge.CreateBmcUser:input_type -> forge.CreateBmcUserRequest + 811, // 1549: forge.Forge.DeleteBmcUser:input_type -> forge.DeleteBmcUserRequest + 813, // 1550: forge.Forge.SetBmcRootPassword:input_type -> forge.SetBmcRootPasswordRequest + 815, // 1551: forge.Forge.ProbeBmcVendor:input_type -> forge.ProbeBmcVendorRequest + 434, // 1552: forge.Forge.EnableInfiniteBoot:input_type -> forge.EnableInfiniteBootRequest + 436, // 1553: forge.Forge.IsInfiniteBootEnabled:input_type -> forge.IsInfiniteBootEnabledRequest + 603, // 1554: forge.Forge.OnDemandMachineValidation:input_type -> forge.MachineValidationOnDemandRequest + 611, // 1555: forge.Forge.OnDemandRackMaintenance:input_type -> forge.RackMaintenanceOnDemandRequest + 134, // 1556: forge.Forge.TpmAddCaCert:input_type -> forge.TpmCaCert + 1093, // 1557: forge.Forge.TpmShowCaCerts:input_type -> google.protobuf.Empty + 1093, // 1558: forge.Forge.TpmShowUnmatchedEkCerts:input_type -> google.protobuf.Empty + 131, // 1559: forge.Forge.TpmDeleteCaCert:input_type -> forge.TpmCaCertId + 669, // 1560: forge.Forge.RedfishBrowse:input_type -> forge.RedfishBrowseRequest + 671, // 1561: forge.Forge.RedfishListActions:input_type -> forge.RedfishListActionsRequest + 676, // 1562: forge.Forge.RedfishCreateAction:input_type -> forge.RedfishCreateActionRequest + 678, // 1563: forge.Forge.RedfishApproveAction:input_type -> forge.RedfishActionID + 678, // 1564: forge.Forge.RedfishApplyAction:input_type -> forge.RedfishActionID + 678, // 1565: forge.Forge.RedfishCancelAction:input_type -> forge.RedfishActionID + 682, // 1566: forge.Forge.UfmBrowse:input_type -> forge.UfmBrowseRequest + 706, // 1567: forge.Forge.GetDesiredFirmwareVersions:input_type -> forge.GetDesiredFirmwareVersionsRequest + 819, // 1568: forge.Forge.UpsertHostFirmwareConfig:input_type -> forge.UpsertHostFirmwareConfigRequest + 820, // 1569: forge.Forge.DeleteHostFirmwareConfig:input_type -> forge.DeleteHostFirmwareConfigRequest + 722, // 1570: forge.Forge.CreateSku:input_type -> forge.SkuList + 1018, // 1571: forge.Forge.GenerateSkuFromMachine:input_type -> common.MachineId + 1018, // 1572: forge.Forge.VerifySkuForMachine:input_type -> common.MachineId + 720, // 1573: forge.Forge.AssignSkuToMachine:input_type -> forge.SkuMachinePair + 721, // 1574: forge.Forge.RemoveSkuAssociation:input_type -> forge.RemoveSkuRequest + 723, // 1575: forge.Forge.DeleteSku:input_type -> forge.SkuIdList + 1093, // 1576: forge.Forge.GetAllSkuIds:input_type -> google.protobuf.Empty + 725, // 1577: forge.Forge.FindSkusByIds:input_type -> forge.SkusByIdsRequest + 735, // 1578: forge.Forge.UpdateSkuMetadata:input_type -> forge.SkuUpdateMetadataRequest + 719, // 1579: forge.Forge.ReplaceSku:input_type -> forge.Sku + 402, // 1580: forge.Forge.GetManagedHostQuarantineState:input_type -> forge.GetManagedHostQuarantineStateRequest + 404, // 1581: forge.Forge.SetManagedHostQuarantineState:input_type -> forge.SetManagedHostQuarantineStateRequest + 406, // 1582: forge.Forge.ClearManagedHostQuarantineState:input_type -> forge.ClearManagedHostQuarantineStateRequest + 1018, // 1583: forge.Forge.ResetHostReprovisioning:input_type -> common.MachineId + 393, // 1584: forge.Forge.CopyBfbToDpuRshim:input_type -> forge.CopyBfbToDpuRshimRequest + 1093, // 1585: forge.Forge.GetAllDpaInterfaceIds:input_type -> google.protobuf.Empty + 730, // 1586: forge.Forge.FindDpaInterfacesByIds:input_type -> forge.DpaInterfacesByIdsRequest + 728, // 1587: forge.Forge.CreateDpaInterface:input_type -> forge.DpaInterfaceCreationRequest + 728, // 1588: forge.Forge.EnsureDpaInterface:input_type -> forge.DpaInterfaceCreationRequest + 733, // 1589: forge.Forge.DeleteDpaInterface:input_type -> forge.DpaInterfaceDeletionRequest + 736, // 1590: forge.Forge.GetPowerOptions:input_type -> forge.PowerOptionRequest + 737, // 1591: forge.Forge.UpdatePowerOption:input_type -> forge.PowerOptionUpdateRequest + 390, // 1592: forge.Forge.AllowIngestionAndPowerOn:input_type -> forge.BmcEndpointRequest + 390, // 1593: forge.Forge.DetermineMachineIngestionState:input_type -> forge.BmcEndpointRequest + 756, // 1594: forge.Forge.FindRackIds:input_type -> forge.RackSearchFilter + 758, // 1595: forge.Forge.FindRacksByIds:input_type -> forge.RacksByIdsRequest + 753, // 1596: forge.Forge.GetRack:input_type -> forge.GetRackRequest + 763, // 1597: forge.Forge.DeleteRack:input_type -> forge.DeleteRackRequest + 764, // 1598: forge.Forge.AdminForceDeleteRack:input_type -> forge.AdminForceDeleteRackRequest + 771, // 1599: forge.Forge.GetRackProfile:input_type -> forge.GetRackProfileRequest + 742, // 1600: forge.Forge.CreateComputeAllocation:input_type -> forge.CreateComputeAllocationRequest + 744, // 1601: forge.Forge.FindComputeAllocationIds:input_type -> forge.FindComputeAllocationIdsRequest + 746, // 1602: forge.Forge.FindComputeAllocationsByIds:input_type -> forge.FindComputeAllocationsByIdsRequest + 749, // 1603: forge.Forge.UpdateComputeAllocation:input_type -> forge.UpdateComputeAllocationRequest + 750, // 1604: forge.Forge.DeleteComputeAllocation:input_type -> forge.DeleteComputeAllocationRequest + 817, // 1605: forge.Forge.SetFirmwareUpdateTimeWindow:input_type -> forge.SetFirmwareUpdateTimeWindowRequest + 826, // 1606: forge.Forge.ListHostFirmware:input_type -> forge.ListHostFirmwareRequest + 1143, // 1607: forge.Forge.PublishMlxDeviceReport:input_type -> mlx_device.PublishMlxDeviceReportRequest + 1144, // 1608: forge.Forge.PublishMlxObservationReport:input_type -> mlx_device.PublishMlxObservationReportRequest + 829, // 1609: forge.Forge.TrimTable:input_type -> forge.TrimTableRequest + 1093, // 1610: forge.Forge.ListNvlinkNmxcEndpoints:input_type -> google.protobuf.Empty + 831, // 1611: forge.Forge.CreateNvlinkNmxcEndpoint:input_type -> forge.NvlinkNmxcEndpoint + 831, // 1612: forge.Forge.UpdateNvlinkNmxcEndpoint:input_type -> forge.NvlinkNmxcEndpoint + 833, // 1613: forge.Forge.DeleteNvlinkNmxcEndpoint:input_type -> forge.DeleteNvlinkNmxcEndpointRequest + 834, // 1614: forge.Forge.CreateRemediation:input_type -> forge.CreateRemediationRequest + 839, // 1615: forge.Forge.ApproveRemediation:input_type -> forge.ApproveRemediationRequest + 840, // 1616: forge.Forge.RevokeRemediation:input_type -> forge.RevokeRemediationRequest + 841, // 1617: forge.Forge.EnableRemediation:input_type -> forge.EnableRemediationRequest + 842, // 1618: forge.Forge.DisableRemediation:input_type -> forge.DisableRemediationRequest + 1093, // 1619: forge.Forge.FindRemediationIds:input_type -> google.protobuf.Empty + 836, // 1620: forge.Forge.FindRemediationsByIds:input_type -> forge.RemediationIdList + 843, // 1621: forge.Forge.FindAppliedRemediationIds:input_type -> forge.FindAppliedRemediationIdsRequest + 845, // 1622: forge.Forge.FindAppliedRemediations:input_type -> forge.FindAppliedRemediationsRequest + 848, // 1623: forge.Forge.GetNextRemediationForMachine:input_type -> forge.GetNextRemediationForMachineRequest + 850, // 1624: forge.Forge.RemediationApplied:input_type -> forge.RemediationAppliedRequest + 852, // 1625: forge.Forge.SetPrimaryDpu:input_type -> forge.SetPrimaryDpuRequest + 853, // 1626: forge.Forge.SetPrimaryInterface:input_type -> forge.SetPrimaryInterfaceRequest + 859, // 1627: forge.Forge.CreateDpuExtensionService:input_type -> forge.CreateDpuExtensionServiceRequest + 860, // 1628: forge.Forge.UpdateDpuExtensionService:input_type -> forge.UpdateDpuExtensionServiceRequest + 861, // 1629: forge.Forge.DeleteDpuExtensionService:input_type -> forge.DeleteDpuExtensionServiceRequest + 863, // 1630: forge.Forge.FindDpuExtensionServiceIds:input_type -> forge.DpuExtensionServiceSearchFilter + 865, // 1631: forge.Forge.FindDpuExtensionServicesByIds:input_type -> forge.DpuExtensionServicesByIdsRequest + 867, // 1632: forge.Forge.GetDpuExtensionServiceVersionsInfo:input_type -> forge.GetDpuExtensionServiceVersionsInfoRequest + 869, // 1633: forge.Forge.FindInstancesByDpuExtensionService:input_type -> forge.FindInstancesByDpuExtensionServiceRequest + 106, // 1634: forge.Forge.TriggerMachineAttestation:input_type -> forge.SpdmMachineAttestationTriggerRequest + 1018, // 1635: forge.Forge.CancelMachineAttestation:input_type -> common.MachineId + 107, // 1636: forge.Forge.ListAttestationMachines:input_type -> forge.SpdmListAttestationMachinesRequest + 1018, // 1637: forge.Forge.GetAttestationMachine:input_type -> common.MachineId + 109, // 1638: forge.Forge.SignMachineIdentity:input_type -> forge.MachineIdentityRequest + 111, // 1639: forge.Forge.GetTenantIdentityConfiguration:input_type -> forge.GetTenantIdentityConfigRequest + 114, // 1640: forge.Forge.SetTenantIdentityConfiguration:input_type -> forge.SetTenantIdentityConfigRequest + 111, // 1641: forge.Forge.DeleteTenantIdentityConfiguration:input_type -> forge.GetTenantIdentityConfigRequest + 119, // 1642: forge.Forge.GetTokenDelegation:input_type -> forge.GetTokenDelegationRequest + 121, // 1643: forge.Forge.SetTokenDelegation:input_type -> forge.TokenDelegationRequest + 119, // 1644: forge.Forge.DeleteTokenDelegation:input_type -> forge.GetTokenDelegationRequest + 122, // 1645: forge.Forge.ReencryptTenantIdentitySecrets:input_type -> forge.ReencryptTenantIdentitySecretsRequest + 127, // 1646: forge.Forge.GetJWKS:input_type -> forge.JwksRequest + 128, // 1647: forge.Forge.GetOpenIDConfiguration:input_type -> forge.OpenIdConfigRequest + 876, // 1648: forge.Forge.ScoutStream:input_type -> forge.ScoutStreamApiBoundMessage + 879, // 1649: forge.Forge.ScoutStreamShowConnections:input_type -> forge.ScoutStreamShowConnectionsRequest + 881, // 1650: forge.Forge.ScoutStreamDisconnect:input_type -> forge.ScoutStreamDisconnectRequest + 883, // 1651: forge.Forge.ScoutStreamPing:input_type -> forge.ScoutStreamAdminPingRequest + 1145, // 1652: forge.Forge.MlxAdminProfileSync:input_type -> mlx_device.MlxAdminProfileSyncRequest + 1146, // 1653: forge.Forge.MlxAdminProfileShow:input_type -> mlx_device.MlxAdminProfileShowRequest + 1147, // 1654: forge.Forge.MlxAdminProfileCompare:input_type -> mlx_device.MlxAdminProfileCompareRequest + 1148, // 1655: forge.Forge.MlxAdminProfileList:input_type -> mlx_device.MlxAdminProfileListRequest + 1149, // 1656: forge.Forge.MlxAdminLockdownLock:input_type -> mlx_device.MlxAdminLockdownLockRequest + 1150, // 1657: forge.Forge.MlxAdminLockdownUnlock:input_type -> mlx_device.MlxAdminLockdownUnlockRequest + 1151, // 1658: forge.Forge.MlxAdminLockdownStatus:input_type -> mlx_device.MlxAdminLockdownStatusRequest + 1152, // 1659: forge.Forge.MlxAdminShowDevice:input_type -> mlx_device.MlxAdminDeviceInfoRequest + 1153, // 1660: forge.Forge.MlxAdminShowMachine:input_type -> mlx_device.MlxAdminDeviceReportRequest + 1154, // 1661: forge.Forge.MlxAdminRegistryList:input_type -> mlx_device.MlxAdminRegistryListRequest + 1155, // 1662: forge.Forge.MlxAdminRegistryShow:input_type -> mlx_device.MlxAdminRegistryShowRequest + 1156, // 1663: forge.Forge.MlxAdminConfigQuery:input_type -> mlx_device.MlxAdminConfigQueryRequest + 1157, // 1664: forge.Forge.MlxAdminConfigSet:input_type -> mlx_device.MlxAdminConfigSetRequest + 1158, // 1665: forge.Forge.MlxAdminConfigSync:input_type -> mlx_device.MlxAdminConfigSyncRequest + 1159, // 1666: forge.Forge.MlxAdminConfigCompare:input_type -> mlx_device.MlxAdminConfigCompareRequest + 793, // 1667: forge.Forge.FindNVLinkPartitionIds:input_type -> forge.NVLinkPartitionSearchFilter + 794, // 1668: forge.Forge.FindNVLinkPartitionsByIds:input_type -> forge.NVLinkPartitionsByIdsRequest + 164, // 1669: forge.Forge.NVLinkPartitionsForTenant:input_type -> forge.TenantSearchQuery + 804, // 1670: forge.Forge.FindNVLinkLogicalPartitionIds:input_type -> forge.NVLinkLogicalPartitionSearchFilter + 805, // 1671: forge.Forge.FindNVLinkLogicalPartitionsByIds:input_type -> forge.NVLinkLogicalPartitionsByIdsRequest + 801, // 1672: forge.Forge.CreateNVLinkLogicalPartition:input_type -> forge.NVLinkLogicalPartitionCreationRequest + 807, // 1673: forge.Forge.UpdateNVLinkLogicalPartition:input_type -> forge.NVLinkLogicalPartitionUpdateRequest + 802, // 1674: forge.Forge.DeleteNVLinkLogicalPartition:input_type -> forge.NVLinkLogicalPartitionDeletionRequest + 164, // 1675: forge.Forge.NVLinkLogicalPartitionsForTenant:input_type -> forge.TenantSearchQuery + 897, // 1676: forge.Forge.GetMachinePositionInfo:input_type -> forge.MachinePositionQuery + 787, // 1677: forge.Forge.NmxcBrowse:input_type -> forge.NmxcBrowseRequest + 900, // 1678: forge.Forge.ModifyDPFState:input_type -> forge.ModifyDPFStateRequest + 902, // 1679: forge.Forge.GetDPFState:input_type -> forge.GetDPFStateRequest + 903, // 1680: forge.Forge.GetDPFHostSnapshot:input_type -> forge.GetDPFHostSnapshotRequest + 905, // 1681: forge.Forge.GetDPFServiceVersions:input_type -> forge.GetDPFServiceVersionsRequest + 914, // 1682: forge.Forge.ComponentPowerControl:input_type -> forge.ComponentPowerControlRequest + 916, // 1683: forge.Forge.ComponentConfigureSwitchCertificate:input_type -> forge.ComponentConfigureSwitchCertificateRequest + 911, // 1684: forge.Forge.GetComponentInventory:input_type -> forge.GetComponentInventoryRequest + 923, // 1685: forge.Forge.UpdateComponentFirmware:input_type -> forge.UpdateComponentFirmwareRequest + 925, // 1686: forge.Forge.GetComponentFirmwareStatus:input_type -> forge.GetComponentFirmwareStatusRequest + 927, // 1687: forge.Forge.ListComponentFirmwareVersions:input_type -> forge.ListComponentFirmwareVersionsRequest + 944, // 1688: forge.Forge.CreateOperatingSystem:input_type -> forge.CreateOperatingSystemRequest + 1038, // 1689: forge.Forge.GetOperatingSystem:input_type -> common.OperatingSystemId + 947, // 1690: forge.Forge.UpdateOperatingSystem:input_type -> forge.UpdateOperatingSystemRequest + 948, // 1691: forge.Forge.DeleteOperatingSystem:input_type -> forge.DeleteOperatingSystemRequest + 950, // 1692: forge.Forge.FindOperatingSystemIds:input_type -> forge.OperatingSystemSearchFilter + 952, // 1693: forge.Forge.FindOperatingSystemsByIds:input_type -> forge.OperatingSystemsByIdsRequest + 954, // 1694: forge.Forge.GetOperatingSystemCachableIpxeTemplateArtifacts:input_type -> forge.GetOperatingSystemCachableIpxeTemplateArtifactsRequest + 957, // 1695: forge.Forge.UpdateOperatingSystemCachableIpxeTemplateArtifacts:input_type -> forge.UpdateOperatingSystemIpxeTemplateArtifactRequest + 959, // 1696: forge.Forge.ReWrapSecrets:input_type -> forge.ReWrapSecretsRequest + 150, // 1697: forge.Forge.Version:output_type -> forge.BuildInfo + 1078, // 1698: forge.Forge.CreateDomain:output_type -> dns.Domain + 1078, // 1699: forge.Forge.UpdateDomain:output_type -> dns.Domain + 1160, // 1700: forge.Forge.DeleteDomain:output_type -> dns.DomainDeletionResult + 1161, // 1701: forge.Forge.FindDomain:output_type -> dns.DomainList + 891, // 1702: forge.Forge.CreateDomainLegacy:output_type -> forge.DomainLegacy + 891, // 1703: forge.Forge.UpdateDomainLegacy:output_type -> forge.DomainLegacy + 894, // 1704: forge.Forge.DeleteDomainLegacy:output_type -> forge.DomainDeletionResultLegacy + 892, // 1705: forge.Forge.FindDomainLegacy:output_type -> forge.DomainListLegacy + 170, // 1706: forge.Forge.CreateVpc:output_type -> forge.Vpc + 173, // 1707: forge.Forge.UpdateVpc:output_type -> forge.VpcUpdateResult + 175, // 1708: forge.Forge.UpdateVpcVirtualization:output_type -> forge.VpcUpdateVirtualizationResult + 177, // 1709: forge.Forge.DeleteVpc:output_type -> forge.VpcDeletionResult + 162, // 1710: forge.Forge.FindVpcIds:output_type -> forge.VpcIdList + 178, // 1711: forge.Forge.FindVpcsByIds:output_type -> forge.VpcList + 932, // 1712: forge.Forge.CreateSpxPartition:output_type -> forge.SpxPartition + 935, // 1713: forge.Forge.DeleteSpxPartition:output_type -> forge.SpxPartitionDeletionResult + 933, // 1714: forge.Forge.FindSpxPartitionIds:output_type -> forge.SpxPartitionIdList + 937, // 1715: forge.Forge.FindSpxPartitionsByIds:output_type -> forge.SpxPartitionList + 179, // 1716: forge.Forge.CreateVpcPrefix:output_type -> forge.VpcPrefix + 185, // 1717: forge.Forge.SearchVpcPrefixes:output_type -> forge.VpcPrefixIdList + 186, // 1718: forge.Forge.GetVpcPrefixes:output_type -> forge.VpcPrefixList + 179, // 1719: forge.Forge.UpdateVpcPrefix:output_type -> forge.VpcPrefix + 189, // 1720: forge.Forge.DeleteVpcPrefix:output_type -> forge.VpcPrefixDeletionResult + 976, // 1721: forge.Forge.FindSitePrefixIds:output_type -> forge.SitePrefixIdList + 977, // 1722: forge.Forge.FindSitePrefixesByIds:output_type -> forge.SitePrefixList + 191, // 1723: forge.Forge.CreateVpcPeering:output_type -> forge.VpcPeering + 192, // 1724: forge.Forge.FindVpcPeeringIds:output_type -> forge.VpcPeeringIdList + 193, // 1725: forge.Forge.FindVpcPeeringsByIds:output_type -> forge.VpcPeeringList + 198, // 1726: forge.Forge.DeleteVpcPeering:output_type -> forge.VpcPeeringDeletionResult + 265, // 1727: forge.Forge.FindNetworkSegmentIds:output_type -> forge.NetworkSegmentIdList + 376, // 1728: forge.Forge.FindNetworkSegmentsByIds:output_type -> forge.NetworkSegmentList + 257, // 1729: forge.Forge.CreateNetworkSegment:output_type -> forge.NetworkSegment + 257, // 1730: forge.Forge.AttachNetworkSegmentToVpc:output_type -> forge.NetworkSegment + 261, // 1731: forge.Forge.DeleteNetworkSegment:output_type -> forge.NetworkSegmentDeletionResult + 376, // 1732: forge.Forge.NetworkSegmentsForVpc:output_type -> forge.NetworkSegmentList + 209, // 1733: forge.Forge.FindIBPartitionIds:output_type -> forge.IBPartitionIdList + 202, // 1734: forge.Forge.FindIBPartitionsByIds:output_type -> forge.IBPartitionList + 201, // 1735: forge.Forge.CreateIBPartition:output_type -> forge.IBPartition + 201, // 1736: forge.Forge.UpdateIBPartition:output_type -> forge.IBPartition + 206, // 1737: forge.Forge.DeleteIBPartition:output_type -> forge.IBPartitionDeletionResult + 202, // 1738: forge.Forge.IBPartitionsForTenant:output_type -> forge.IBPartitionList + 213, // 1739: forge.Forge.FindPowerShelves:output_type -> forge.PowerShelfList + 910, // 1740: forge.Forge.FindPowerShelfIds:output_type -> forge.PowerShelfIdList + 213, // 1741: forge.Forge.FindPowerShelvesByIds:output_type -> forge.PowerShelfList + 216, // 1742: forge.Forge.DeletePowerShelf:output_type -> forge.PowerShelfDeletionResult + 942, // 1743: forge.Forge.AdminForceDeletePowerShelf:output_type -> forge.AdminForceDeletePowerShelfResponse + 1093, // 1744: forge.Forge.SetPowerShelfMaintenance:output_type -> google.protobuf.Empty + 233, // 1745: forge.Forge.FindSwitches:output_type -> forge.SwitchList + 909, // 1746: forge.Forge.FindSwitchIds:output_type -> forge.SwitchIdList + 233, // 1747: forge.Forge.FindSwitchesByIds:output_type -> forge.SwitchList + 236, // 1748: forge.Forge.DeleteSwitch:output_type -> forge.SwitchDeletionResult + 940, // 1749: forge.Forge.AdminForceDeleteSwitch:output_type -> forge.AdminForceDeleteSwitchResponse + 253, // 1750: forge.Forge.FindIBFabricIds:output_type -> forge.IBFabricIdList + 306, // 1751: forge.Forge.AllocateInstance:output_type -> forge.Instance + 279, // 1752: forge.Forge.AllocateInstances:output_type -> forge.BatchInstanceAllocationResponse + 324, // 1753: forge.Forge.ReleaseInstance:output_type -> forge.InstanceReleaseResult + 306, // 1754: forge.Forge.UpdateInstanceOperatingSystem:output_type -> forge.Instance + 306, // 1755: forge.Forge.UpdateInstanceConfig:output_type -> forge.Instance + 275, // 1756: forge.Forge.FindInstanceIds:output_type -> forge.InstanceIdList + 271, // 1757: forge.Forge.FindInstancesByIds:output_type -> forge.InstanceList + 271, // 1758: forge.Forge.FindInstanceByMachineID:output_type -> forge.InstanceList + 397, // 1759: forge.Forge.GetManagedHostNetworkConfig:output_type -> forge.ManagedHostNetworkConfigResponse + 1093, // 1760: forge.Forge.RecordDpuNetworkStatus:output_type -> google.protobuf.Empty + 477, // 1761: forge.Forge.ListMachineHealthReports:output_type -> forge.ListHealthReportResponse + 1093, // 1762: forge.Forge.InsertMachineHealthReport:output_type -> google.protobuf.Empty + 1093, // 1763: forge.Forge.RemoveMachineHealthReport:output_type -> google.protobuf.Empty + 477, // 1764: forge.Forge.ListRackHealthReports:output_type -> forge.ListHealthReportResponse + 1093, // 1765: forge.Forge.InsertRackHealthReport:output_type -> google.protobuf.Empty + 1093, // 1766: forge.Forge.RemoveRackHealthReport:output_type -> google.protobuf.Empty + 477, // 1767: forge.Forge.ListSwitchHealthReports:output_type -> forge.ListHealthReportResponse + 1093, // 1768: forge.Forge.InsertSwitchHealthReport:output_type -> google.protobuf.Empty + 1093, // 1769: forge.Forge.RemoveSwitchHealthReport:output_type -> google.protobuf.Empty + 477, // 1770: forge.Forge.ListPowerShelfHealthReports:output_type -> forge.ListHealthReportResponse + 1093, // 1771: forge.Forge.InsertPowerShelfHealthReport:output_type -> google.protobuf.Empty + 1093, // 1772: forge.Forge.RemovePowerShelfHealthReport:output_type -> google.protobuf.Empty + 477, // 1773: forge.Forge.ListNVLinkDomainHealthReports:output_type -> forge.ListHealthReportResponse + 1093, // 1774: forge.Forge.InsertNVLinkDomainHealthReport:output_type -> google.protobuf.Empty + 1093, // 1775: forge.Forge.RemoveNVLinkDomainHealthReport:output_type -> google.protobuf.Empty + 477, // 1776: forge.Forge.ListHealthReportOverrides:output_type -> forge.ListHealthReportResponse + 1093, // 1777: forge.Forge.InsertHealthReportOverride:output_type -> google.protobuf.Empty + 1093, // 1778: forge.Forge.RemoveHealthReportOverride:output_type -> google.protobuf.Empty + 416, // 1779: forge.Forge.DpuAgentUpgradeCheck:output_type -> forge.DpuAgentUpgradeCheckResponse + 418, // 1780: forge.Forge.DpuAgentUpgradePolicyAction:output_type -> forge.DpuAgentUpgradePolicyResponse + 1162, // 1781: forge.Forge.LookupRecord:output_type -> dns.DnsResourceRecordLookupResponse + 1163, // 1782: forge.Forge.GetAllDomains:output_type -> dns.GetAllDomainsResponse + 1164, // 1783: forge.Forge.GetAllDomainMetadata:output_type -> dns.DomainMetadataResponse + 270, // 1784: forge.Forge.InvokeInstancePower:output_type -> forge.InstancePowerResult + 443, // 1785: forge.Forge.ForgeAgentControl:output_type -> forge.ForgeAgentControlResponse + 450, // 1786: forge.Forge.DiscoverMachine:output_type -> forge.MachineDiscoveryResult + 449, // 1787: forge.Forge.RenewMachineCertificate:output_type -> forge.MachineCertificateResult + 451, // 1788: forge.Forge.DiscoveryCompleted:output_type -> forge.MachineDiscoveryCompletedResponse + 452, // 1789: forge.Forge.CleanupMachineCompleted:output_type -> forge.MachineCleanupResult + 454, // 1790: forge.Forge.ReportForgeScoutError:output_type -> forge.ForgeScoutErrorReportResult + 375, // 1791: forge.Forge.DiscoverDhcp:output_type -> forge.DhcpRecord + 374, // 1792: forge.Forge.ExpireDhcpLease:output_type -> forge.ExpireDhcpLeaseResponse + 343, // 1793: forge.Forge.AssignStaticAddress:output_type -> forge.AssignStaticAddressResponse + 345, // 1794: forge.Forge.RemoveStaticAddress:output_type -> forge.RemoveStaticAddressResponse + 348, // 1795: forge.Forge.FindInterfaceAddresses:output_type -> forge.FindInterfaceAddressesResponse + 338, // 1796: forge.Forge.FindInterfaces:output_type -> forge.InterfaceList + 1093, // 1797: forge.Forge.DeleteInterface:output_type -> google.protobuf.Empty + 518, // 1798: forge.Forge.FindIpAddress:output_type -> forge.FindIpAddressResponse + 1079, // 1799: forge.Forge.FindMachineIds:output_type -> common.MachineIdList + 339, // 1800: forge.Forge.FindMachinesByIds:output_type -> forge.MachineList + 328, // 1801: forge.Forge.FindMachineStateHistories:output_type -> forge.MachineStateHistories + 331, // 1802: forge.Forge.FindMachineHealthHistories:output_type -> forge.HealthHistories + 240, // 1803: forge.Forge.FindPowerShelfStateHistories:output_type -> forge.StateHistories + 240, // 1804: forge.Forge.FindRackStateHistories:output_type -> forge.StateHistories + 240, // 1805: forge.Forge.FindSwitchStateHistories:output_type -> forge.StateHistories + 240, // 1806: forge.Forge.FindNetworkSegmentStateHistories:output_type -> forge.StateHistories + 240, // 1807: forge.Forge.FindVpcPrefixStateHistories:output_type -> forge.StateHistories + 337, // 1808: forge.Forge.FindTenantOrganizationIds:output_type -> forge.TenantOrganizationIdList + 336, // 1809: forge.Forge.FindTenantsByOrganizationIds:output_type -> forge.TenantList + 543, // 1810: forge.Forge.FindConnectedDevicesByDpuMachineIds:output_type -> forge.ConnectedDeviceList + 547, // 1811: forge.Forge.FindMachineIdsByBmcIps:output_type -> forge.MachineIdBmcIpPairs + 546, // 1812: forge.Forge.FindMacAddressByBmcIp:output_type -> forge.MacAddressBmcIp + 544, // 1813: forge.Forge.FindBmcIps:output_type -> forge.BmcIpList + 520, // 1814: forge.Forge.IdentifyUuid:output_type -> forge.IdentifyUuidResponse + 523, // 1815: forge.Forge.IdentifyMac:output_type -> forge.IdentifyMacResponse + 525, // 1816: forge.Forge.IdentifySerial:output_type -> forge.IdentifySerialResponse + 439, // 1817: forge.Forge.GetBMCMetaData:output_type -> forge.BMCMetaDataGetResponse + 441, // 1818: forge.Forge.UpdateMachineCredentials:output_type -> forge.MachineCredentialsUpdateResponse + 456, // 1819: forge.Forge.GetPxeInstructions:output_type -> forge.PxeInstructions + 460, // 1820: forge.Forge.GetCloudInitInstructions:output_type -> forge.CloudInitInstructions + 153, // 1821: forge.Forge.Echo:output_type -> forge.EchoResponse + 487, // 1822: forge.Forge.CreateTenant:output_type -> forge.CreateTenantResponse + 491, // 1823: forge.Forge.FindTenant:output_type -> forge.FindTenantResponse + 489, // 1824: forge.Forge.UpdateTenant:output_type -> forge.UpdateTenantResponse + 497, // 1825: forge.Forge.CreateTenantKeyset:output_type -> forge.CreateTenantKeysetResponse + 504, // 1826: forge.Forge.FindTenantKeysetIds:output_type -> forge.TenantKeysetIdList + 498, // 1827: forge.Forge.FindTenantKeysetsByIds:output_type -> forge.TenantKeySetList + 500, // 1828: forge.Forge.UpdateTenantKeyset:output_type -> forge.UpdateTenantKeysetResponse + 502, // 1829: forge.Forge.DeleteTenantKeyset:output_type -> forge.DeleteTenantKeysetResponse + 507, // 1830: forge.Forge.ValidateTenantPublicKey:output_type -> forge.ValidateTenantPublicKeyResponse + 381, // 1831: forge.Forge.GetBmcCredentials:output_type -> forge.GetBmcCredentialsResponse + 381, // 1832: forge.Forge.GetSwitchNvosCredentials:output_type -> forge.GetBmcCredentialsResponse + 414, // 1833: forge.Forge.GetAllManagedHostNetworkStatus:output_type -> forge.ManagedHostNetworkStatusResponse + 1165, // 1834: forge.Forge.GetSiteExplorationReport:output_type -> site_explorer.SiteExplorationReport + 1166, // 1835: forge.Forge.GetSiteExplorerLastRun:output_type -> site_explorer.SiteExplorerLastRunResponse + 1093, // 1836: forge.Forge.ClearSiteExplorationError:output_type -> google.protobuf.Empty + 628, // 1837: forge.Forge.IsBmcInManagedHost:output_type -> forge.IsBmcInManagedHostResponse + 629, // 1838: forge.Forge.BmcCredentialStatus:output_type -> forge.BmcCredentialStatusResponse + 1080, // 1839: forge.Forge.Explore:output_type -> site_explorer.EndpointExplorationReport + 1093, // 1840: forge.Forge.ReExploreEndpoint:output_type -> google.protobuf.Empty + 1167, // 1841: forge.Forge.RefreshEndpointReport:output_type -> site_explorer.ExploredEndpoint + 389, // 1842: forge.Forge.DeleteExploredEndpoint:output_type -> forge.DeleteExploredEndpointResponse + 1093, // 1843: forge.Forge.PauseExploredEndpointRemediation:output_type -> google.protobuf.Empty + 1168, // 1844: forge.Forge.FindExploredEndpointIds:output_type -> site_explorer.ExploredEndpointIdList + 1169, // 1845: forge.Forge.FindExploredEndpointsByIds:output_type -> site_explorer.ExploredEndpointList + 1170, // 1846: forge.Forge.FindExploredManagedHostIds:output_type -> site_explorer.ExploredManagedHostIdList + 1171, // 1847: forge.Forge.FindExploredManagedHostsByIds:output_type -> site_explorer.ExploredManagedHostList + 1172, // 1848: forge.Forge.FindExploredMlxDeviceHostIds:output_type -> site_explorer.ExploredMlxDeviceHostIdList + 1173, // 1849: forge.Forge.FindExploredMlxDevicesByIds:output_type -> site_explorer.ExploredMlxDeviceList + 1093, // 1850: forge.Forge.UpdateMachineHardwareInfo:output_type -> google.protobuf.Empty + 420, // 1851: forge.Forge.AdminForceDeleteMachine:output_type -> forge.AdminForceDeleteMachineResponse + 509, // 1852: forge.Forge.AdminListResourcePools:output_type -> forge.ResourcePools + 512, // 1853: forge.Forge.AdminGrowResourcePool:output_type -> forge.GrowResourcePoolResponse + 1093, // 1854: forge.Forge.UpdateMachineMetadata:output_type -> google.protobuf.Empty + 1093, // 1855: forge.Forge.UpdateRackMetadata:output_type -> google.protobuf.Empty + 1093, // 1856: forge.Forge.UpdateSwitchMetadata:output_type -> google.protobuf.Empty + 1093, // 1857: forge.Forge.UpdatePowerShelfMetadata:output_type -> google.protobuf.Empty + 1093, // 1858: forge.Forge.UpdateMachineNvLinkInfo:output_type -> google.protobuf.Empty + 1093, // 1859: forge.Forge.SetMaintenance:output_type -> google.protobuf.Empty + 1093, // 1860: forge.Forge.SetDynamicConfig:output_type -> google.protobuf.Empty + 1093, // 1861: forge.Forge.TriggerDpuReprovisioning:output_type -> google.protobuf.Empty + 528, // 1862: forge.Forge.ListDpuWaitingForReprovisioning:output_type -> forge.DpuReprovisioningListResponse + 1093, // 1863: forge.Forge.TriggerHostReprovisioning:output_type -> google.protobuf.Empty + 533, // 1864: forge.Forge.ListHostsWaitingForReprovisioning:output_type -> forge.HostReprovisioningListResponse + 1093, // 1865: forge.Forge.TriggerBmcCredentialRotation:output_type -> google.protobuf.Empty + 1093, // 1866: forge.Forge.TriggerUefiCredentialRotation:output_type -> google.protobuf.Empty + 1093, // 1867: forge.Forge.MarkManualFirmwareUpgradeComplete:output_type -> google.protobuf.Empty + 1093, // 1868: forge.Forge.ReportScoutFirmwareUpgradeStatus:output_type -> google.protobuf.Empty + 539, // 1869: forge.Forge.GetDpuInfoList:output_type -> forge.GetDpuInfoListResponse + 541, // 1870: forge.Forge.GetMachineBootOverride:output_type -> forge.MachineBootOverride + 1093, // 1871: forge.Forge.SetMachineBootOverride:output_type -> google.protobuf.Empty + 1093, // 1872: forge.Forge.ClearMachineBootOverride:output_type -> google.protobuf.Empty + 967, // 1873: forge.Forge.GetMachineBootInterfaces:output_type -> forge.GetMachineBootInterfacesResponse + 552, // 1874: forge.Forge.GetNetworkTopology:output_type -> forge.NetworkTopologyData + 552, // 1875: forge.Forge.FindNetworkDevicesByDeviceIds:output_type -> forge.NetworkTopologyData + 142, // 1876: forge.Forge.CreateCredential:output_type -> forge.CredentialCreationResult + 143, // 1877: forge.Forge.DeleteCredential:output_type -> forge.CredentialDeletionResult + 145, // 1878: forge.Forge.RotateCredential:output_type -> forge.RotateCredentialResult + 148, // 1879: forge.Forge.GetCredentialRotationStatus:output_type -> forge.CredentialRotationStatusResult + 969, // 1880: forge.Forge.GetContainerRegistryCredential:output_type -> forge.GetContainerRegistryCredentialResponse + 1093, // 1881: forge.Forge.SetContainerRegistryCredential:output_type -> google.protobuf.Empty + 554, // 1882: forge.Forge.GetRouteServers:output_type -> forge.RouteServerEntries + 1093, // 1883: forge.Forge.AddRouteServers:output_type -> google.protobuf.Empty + 1093, // 1884: forge.Forge.RemoveRouteServers:output_type -> google.protobuf.Empty + 1093, // 1885: forge.Forge.ReplaceRouteServers:output_type -> google.protobuf.Empty + 1093, // 1886: forge.Forge.UpdateAgentReportedInventory:output_type -> google.protobuf.Empty + 319, // 1887: forge.Forge.UpdateInstancePhoneHomeLastContact:output_type -> forge.InstancePhoneHomeLastContactResponse + 557, // 1888: forge.Forge.SetHostUefiPassword:output_type -> forge.SetHostUefiPasswordResponse + 559, // 1889: forge.Forge.ClearHostUefiPassword:output_type -> forge.ClearHostUefiPasswordResponse + 561, // 1890: forge.Forge.SetDpuUefiPassword:output_type -> forge.SetDpuUefiPasswordResponse + 1093, // 1891: forge.Forge.AddExpectedMachine:output_type -> google.protobuf.Empty + 1093, // 1892: forge.Forge.DeleteExpectedMachine:output_type -> google.protobuf.Empty + 1093, // 1893: forge.Forge.UpdateExpectedMachine:output_type -> google.protobuf.Empty + 573, // 1894: forge.Forge.GetExpectedMachine:output_type -> forge.ExpectedMachine + 575, // 1895: forge.Forge.GetAllExpectedMachines:output_type -> forge.ExpectedMachineList + 1093, // 1896: forge.Forge.ReplaceAllExpectedMachines:output_type -> google.protobuf.Empty + 1093, // 1897: forge.Forge.DeleteAllExpectedMachines:output_type -> google.protobuf.Empty + 576, // 1898: forge.Forge.GetAllExpectedMachinesLinked:output_type -> forge.LinkedExpectedMachineList + 578, // 1899: forge.Forge.GetAllUnexpectedMachines:output_type -> forge.UnexpectedMachineList + 582, // 1900: forge.Forge.CreateExpectedMachines:output_type -> forge.BatchExpectedMachineOperationResponse + 582, // 1901: forge.Forge.UpdateExpectedMachines:output_type -> forge.BatchExpectedMachineOperationResponse + 1093, // 1902: forge.Forge.AddExpectedPowerShelf:output_type -> google.protobuf.Empty + 1093, // 1903: forge.Forge.DeleteExpectedPowerShelf:output_type -> google.protobuf.Empty + 1093, // 1904: forge.Forge.UpdateExpectedPowerShelf:output_type -> google.protobuf.Empty + 222, // 1905: forge.Forge.GetExpectedPowerShelf:output_type -> forge.ExpectedPowerShelf + 224, // 1906: forge.Forge.GetAllExpectedPowerShelves:output_type -> forge.ExpectedPowerShelfList + 1093, // 1907: forge.Forge.ReplaceAllExpectedPowerShelves:output_type -> google.protobuf.Empty + 1093, // 1908: forge.Forge.DeleteAllExpectedPowerShelves:output_type -> google.protobuf.Empty + 225, // 1909: forge.Forge.GetAllExpectedPowerShelvesLinked:output_type -> forge.LinkedExpectedPowerShelfList + 1093, // 1910: forge.Forge.AddExpectedSwitch:output_type -> google.protobuf.Empty + 1093, // 1911: forge.Forge.DeleteExpectedSwitch:output_type -> google.protobuf.Empty + 1093, // 1912: forge.Forge.UpdateExpectedSwitch:output_type -> google.protobuf.Empty + 244, // 1913: forge.Forge.GetExpectedSwitch:output_type -> forge.ExpectedSwitch + 246, // 1914: forge.Forge.GetAllExpectedSwitches:output_type -> forge.ExpectedSwitchList + 1093, // 1915: forge.Forge.ReplaceAllExpectedSwitches:output_type -> google.protobuf.Empty + 1093, // 1916: forge.Forge.DeleteAllExpectedSwitches:output_type -> google.protobuf.Empty + 247, // 1917: forge.Forge.GetAllExpectedSwitchesLinked:output_type -> forge.LinkedExpectedSwitchList + 1093, // 1918: forge.Forge.AddExpectedRack:output_type -> google.protobuf.Empty + 1093, // 1919: forge.Forge.DeleteExpectedRack:output_type -> google.protobuf.Empty + 1093, // 1920: forge.Forge.UpdateExpectedRack:output_type -> google.protobuf.Empty + 249, // 1921: forge.Forge.GetExpectedRack:output_type -> forge.ExpectedRack + 251, // 1922: forge.Forge.GetAllExpectedRacks:output_type -> forge.ExpectedRackList + 1093, // 1923: forge.Forge.ReplaceAllExpectedRacks:output_type -> google.protobuf.Empty + 1093, // 1924: forge.Forge.DeleteAllExpectedRacks:output_type -> google.protobuf.Empty + 139, // 1925: forge.Forge.AttestQuote:output_type -> forge.AttestQuoteResponse + 656, // 1926: forge.Forge.CreateInstanceType:output_type -> forge.CreateInstanceTypeResponse + 658, // 1927: forge.Forge.FindInstanceTypeIds:output_type -> forge.FindInstanceTypeIdsResponse + 660, // 1928: forge.Forge.FindInstanceTypesByIds:output_type -> forge.FindInstanceTypesByIdsResponse + 663, // 1929: forge.Forge.UpdateInstanceType:output_type -> forge.UpdateInstanceTypeResponse + 662, // 1930: forge.Forge.DeleteInstanceType:output_type -> forge.DeleteInstanceTypeResponse + 666, // 1931: forge.Forge.AssociateMachinesWithInstanceType:output_type -> forge.AssociateMachinesWithInstanceTypeResponse + 668, // 1932: forge.Forge.RemoveMachineInstanceTypeAssociation:output_type -> forge.RemoveMachineInstanceTypeAssociationResponse + 1174, // 1933: forge.Forge.CreateMeasurementBundle:output_type -> measured_boot.CreateMeasurementBundleResponse + 1175, // 1934: forge.Forge.DeleteMeasurementBundle:output_type -> measured_boot.DeleteMeasurementBundleResponse + 1176, // 1935: forge.Forge.RenameMeasurementBundle:output_type -> measured_boot.RenameMeasurementBundleResponse + 1177, // 1936: forge.Forge.UpdateMeasurementBundle:output_type -> measured_boot.UpdateMeasurementBundleResponse + 1178, // 1937: forge.Forge.ShowMeasurementBundle:output_type -> measured_boot.ShowMeasurementBundleResponse + 1179, // 1938: forge.Forge.ShowMeasurementBundles:output_type -> measured_boot.ShowMeasurementBundlesResponse + 1180, // 1939: forge.Forge.ListMeasurementBundles:output_type -> measured_boot.ListMeasurementBundlesResponse + 1181, // 1940: forge.Forge.ListMeasurementBundleMachines:output_type -> measured_boot.ListMeasurementBundleMachinesResponse + 1178, // 1941: forge.Forge.FindClosestBundleMatch:output_type -> measured_boot.ShowMeasurementBundleResponse + 1182, // 1942: forge.Forge.DeleteMeasurementJournal:output_type -> measured_boot.DeleteMeasurementJournalResponse + 1183, // 1943: forge.Forge.ShowMeasurementJournal:output_type -> measured_boot.ShowMeasurementJournalResponse + 1184, // 1944: forge.Forge.ShowMeasurementJournals:output_type -> measured_boot.ShowMeasurementJournalsResponse + 1185, // 1945: forge.Forge.ListMeasurementJournal:output_type -> measured_boot.ListMeasurementJournalResponse + 1186, // 1946: forge.Forge.AttestCandidateMachine:output_type -> measured_boot.AttestCandidateMachineResponse + 1187, // 1947: forge.Forge.ShowCandidateMachine:output_type -> measured_boot.ShowCandidateMachineResponse + 1188, // 1948: forge.Forge.ShowCandidateMachines:output_type -> measured_boot.ShowCandidateMachinesResponse + 1189, // 1949: forge.Forge.ListCandidateMachines:output_type -> measured_boot.ListCandidateMachinesResponse + 1190, // 1950: forge.Forge.CreateMeasurementSystemProfile:output_type -> measured_boot.CreateMeasurementSystemProfileResponse + 1191, // 1951: forge.Forge.DeleteMeasurementSystemProfile:output_type -> measured_boot.DeleteMeasurementSystemProfileResponse + 1192, // 1952: forge.Forge.RenameMeasurementSystemProfile:output_type -> measured_boot.RenameMeasurementSystemProfileResponse + 1193, // 1953: forge.Forge.ShowMeasurementSystemProfile:output_type -> measured_boot.ShowMeasurementSystemProfileResponse + 1194, // 1954: forge.Forge.ShowMeasurementSystemProfiles:output_type -> measured_boot.ShowMeasurementSystemProfilesResponse + 1195, // 1955: forge.Forge.ListMeasurementSystemProfiles:output_type -> measured_boot.ListMeasurementSystemProfilesResponse + 1196, // 1956: forge.Forge.ListMeasurementSystemProfileBundles:output_type -> measured_boot.ListMeasurementSystemProfileBundlesResponse + 1197, // 1957: forge.Forge.ListMeasurementSystemProfileMachines:output_type -> measured_boot.ListMeasurementSystemProfileMachinesResponse + 1198, // 1958: forge.Forge.CreateMeasurementReport:output_type -> measured_boot.CreateMeasurementReportResponse + 1199, // 1959: forge.Forge.DeleteMeasurementReport:output_type -> measured_boot.DeleteMeasurementReportResponse + 1200, // 1960: forge.Forge.PromoteMeasurementReport:output_type -> measured_boot.PromoteMeasurementReportResponse + 1201, // 1961: forge.Forge.RevokeMeasurementReport:output_type -> measured_boot.RevokeMeasurementReportResponse + 1202, // 1962: forge.Forge.ShowMeasurementReportForId:output_type -> measured_boot.ShowMeasurementReportForIdResponse + 1203, // 1963: forge.Forge.ShowMeasurementReportsForMachine:output_type -> measured_boot.ShowMeasurementReportsForMachineResponse + 1204, // 1964: forge.Forge.ShowMeasurementReports:output_type -> measured_boot.ShowMeasurementReportsResponse + 1205, // 1965: forge.Forge.ListMeasurementReport:output_type -> measured_boot.ListMeasurementReportResponse + 1206, // 1966: forge.Forge.MatchMeasurementReport:output_type -> measured_boot.MatchMeasurementReportResponse + 1207, // 1967: forge.Forge.ImportSiteMeasurements:output_type -> measured_boot.ImportSiteMeasurementsResponse + 1208, // 1968: forge.Forge.ExportSiteMeasurements:output_type -> measured_boot.ExportSiteMeasurementsResponse + 1209, // 1969: forge.Forge.AddMeasurementTrustedMachine:output_type -> measured_boot.AddMeasurementTrustedMachineResponse + 1210, // 1970: forge.Forge.RemoveMeasurementTrustedMachine:output_type -> measured_boot.RemoveMeasurementTrustedMachineResponse + 1211, // 1971: forge.Forge.AddMeasurementTrustedProfile:output_type -> measured_boot.AddMeasurementTrustedProfileResponse + 1212, // 1972: forge.Forge.RemoveMeasurementTrustedProfile:output_type -> measured_boot.RemoveMeasurementTrustedProfileResponse + 1213, // 1973: forge.Forge.ListMeasurementTrustedMachines:output_type -> measured_boot.ListMeasurementTrustedMachinesResponse + 1214, // 1974: forge.Forge.ListMeasurementTrustedProfiles:output_type -> measured_boot.ListMeasurementTrustedProfilesResponse + 1215, // 1975: forge.Forge.ListAttestationSummary:output_type -> measured_boot.ListAttestationSummaryResponse + 687, // 1976: forge.Forge.CreateNetworkSecurityGroup:output_type -> forge.CreateNetworkSecurityGroupResponse + 689, // 1977: forge.Forge.FindNetworkSecurityGroupIds:output_type -> forge.FindNetworkSecurityGroupIdsResponse + 691, // 1978: forge.Forge.FindNetworkSecurityGroupsByIds:output_type -> forge.FindNetworkSecurityGroupsByIdsResponse + 692, // 1979: forge.Forge.UpdateNetworkSecurityGroup:output_type -> forge.UpdateNetworkSecurityGroupResponse + 695, // 1980: forge.Forge.DeleteNetworkSecurityGroup:output_type -> forge.DeleteNetworkSecurityGroupResponse + 698, // 1981: forge.Forge.GetNetworkSecurityGroupPropagationStatus:output_type -> forge.GetNetworkSecurityGroupPropagationStatusResponse + 705, // 1982: forge.Forge.GetNetworkSecurityGroupAttachments:output_type -> forge.GetNetworkSecurityGroupAttachmentsResponse + 563, // 1983: forge.Forge.CreateOsImage:output_type -> forge.OsImage + 567, // 1984: forge.Forge.DeleteOsImage:output_type -> forge.DeleteOsImageResponse + 565, // 1985: forge.Forge.ListOsImage:output_type -> forge.ListOsImageResponse + 563, // 1986: forge.Forge.GetOsImage:output_type -> forge.OsImage + 563, // 1987: forge.Forge.UpdateOsImage:output_type -> forge.OsImage + 282, // 1988: forge.Forge.GetIpxeTemplate:output_type -> forge.IpxeTemplate + 570, // 1989: forge.Forge.ListIpxeTemplates:output_type -> forge.IpxeTemplateList + 583, // 1990: forge.Forge.RebootCompleted:output_type -> forge.MachineRebootCompletedResponse + 1093, // 1991: forge.Forge.PersistValidationResult:output_type -> google.protobuf.Empty + 590, // 1992: forge.Forge.GetMachineValidationResults:output_type -> forge.MachineValidationResultList + 587, // 1993: forge.Forge.MachineValidationCompleted:output_type -> forge.MachineValidationCompletedResponse + 595, // 1994: forge.Forge.MachineSetAutoUpdate:output_type -> forge.MachineSetAutoUpdateResponse + 598, // 1995: forge.Forge.GetMachineValidationExternalConfig:output_type -> forge.GetMachineValidationExternalConfigResponse + 600, // 1996: forge.Forge.GetMachineValidationExternalConfigs:output_type -> forge.GetMachineValidationExternalConfigsResponse + 1093, // 1997: forge.Forge.AddUpdateMachineValidationExternalConfig:output_type -> google.protobuf.Empty + 617, // 1998: forge.Forge.GetMachineValidationRuns:output_type -> forge.MachineValidationRunList + 620, // 1999: forge.Forge.FindMachineValidationRunItemIds:output_type -> forge.MachineValidationRunItemIdList + 622, // 2000: forge.Forge.FindMachineValidationRunItemsByIds:output_type -> forge.MachineValidationRunItemList + 625, // 2001: forge.Forge.GetMachineValidationAttempt:output_type -> forge.MachineValidationAttempt + 627, // 2002: forge.Forge.HeartbeatMachineValidationRun:output_type -> forge.MachineValidationHeartbeatResponse + 1093, // 2003: forge.Forge.RemoveMachineValidationExternalConfig:output_type -> google.protobuf.Empty + 634, // 2004: forge.Forge.GetMachineValidationTests:output_type -> forge.MachineValidationTestsGetResponse + 633, // 2005: forge.Forge.AddMachineValidationTest:output_type -> forge.MachineValidationTestAddUpdateResponse + 633, // 2006: forge.Forge.UpdateMachineValidationTest:output_type -> forge.MachineValidationTestAddUpdateResponse + 636, // 2007: forge.Forge.MachineValidationTestVerfied:output_type -> forge.MachineValidationTestVerfiedResponse + 638, // 2008: forge.Forge.MachineValidationTestNextVersion:output_type -> forge.MachineValidationTestNextVersionResponse + 641, // 2009: forge.Forge.MachineValidationTestEnableDisableTest:output_type -> forge.MachineValidationTestEnableDisableTestResponse + 643, // 2010: forge.Forge.UpdateMachineValidationRun:output_type -> forge.MachineValidationRunResponse + 433, // 2011: forge.Forge.AdminBmcReset:output_type -> forge.AdminBmcResetResponse + 614, // 2012: forge.Forge.AdminPowerControl:output_type -> forge.AdminPowerControlResponse + 421, // 2013: forge.Forge.DisableSecureBoot:output_type -> forge.DisableSecureBootResponse + 423, // 2014: forge.Forge.Lockdown:output_type -> forge.LockdownResponse + 1216, // 2015: forge.Forge.LockdownStatus:output_type -> site_explorer.LockdownStatus + 427, // 2016: forge.Forge.MachineSetup:output_type -> forge.MachineSetupResponse + 429, // 2017: forge.Forge.SetDpuFirstBootOrder:output_type -> forge.SetDpuFirstBootOrderResponse + 810, // 2018: forge.Forge.CreateBmcUser:output_type -> forge.CreateBmcUserResponse + 812, // 2019: forge.Forge.DeleteBmcUser:output_type -> forge.DeleteBmcUserResponse + 814, // 2020: forge.Forge.SetBmcRootPassword:output_type -> forge.SetBmcRootPasswordResponse + 816, // 2021: forge.Forge.ProbeBmcVendor:output_type -> forge.ProbeBmcVendorResponse + 435, // 2022: forge.Forge.EnableInfiniteBoot:output_type -> forge.EnableInfiniteBootResponse + 437, // 2023: forge.Forge.IsInfiniteBootEnabled:output_type -> forge.IsInfiniteBootEnabledResponse + 604, // 2024: forge.Forge.OnDemandMachineValidation:output_type -> forge.MachineValidationOnDemandResponse + 612, // 2025: forge.Forge.OnDemandRackMaintenance:output_type -> forge.RackMaintenanceOnDemandResponse + 130, // 2026: forge.Forge.TpmAddCaCert:output_type -> forge.TpmCaAddedCaStatus + 136, // 2027: forge.Forge.TpmShowCaCerts:output_type -> forge.TpmCaCertDetailCollection + 133, // 2028: forge.Forge.TpmShowUnmatchedEkCerts:output_type -> forge.TpmEkCertStatusCollection + 1093, // 2029: forge.Forge.TpmDeleteCaCert:output_type -> google.protobuf.Empty + 670, // 2030: forge.Forge.RedfishBrowse:output_type -> forge.RedfishBrowseResponse + 672, // 2031: forge.Forge.RedfishListActions:output_type -> forge.RedfishListActionsResponse + 677, // 2032: forge.Forge.RedfishCreateAction:output_type -> forge.RedfishCreateActionResponse + 679, // 2033: forge.Forge.RedfishApproveAction:output_type -> forge.RedfishApproveActionResponse + 680, // 2034: forge.Forge.RedfishApplyAction:output_type -> forge.RedfishApplyActionResponse + 681, // 2035: forge.Forge.RedfishCancelAction:output_type -> forge.RedfishCancelActionResponse + 683, // 2036: forge.Forge.UfmBrowse:output_type -> forge.UfmBrowseResponse + 707, // 2037: forge.Forge.GetDesiredFirmwareVersions:output_type -> forge.GetDesiredFirmwareVersionsResponse + 825, // 2038: forge.Forge.UpsertHostFirmwareConfig:output_type -> forge.HostFirmwareConfigResponse + 1093, // 2039: forge.Forge.DeleteHostFirmwareConfig:output_type -> google.protobuf.Empty + 723, // 2040: forge.Forge.CreateSku:output_type -> forge.SkuIdList + 719, // 2041: forge.Forge.GenerateSkuFromMachine:output_type -> forge.Sku + 1093, // 2042: forge.Forge.VerifySkuForMachine:output_type -> google.protobuf.Empty + 1093, // 2043: forge.Forge.AssignSkuToMachine:output_type -> google.protobuf.Empty + 1093, // 2044: forge.Forge.RemoveSkuAssociation:output_type -> google.protobuf.Empty + 1093, // 2045: forge.Forge.DeleteSku:output_type -> google.protobuf.Empty + 723, // 2046: forge.Forge.GetAllSkuIds:output_type -> forge.SkuIdList + 722, // 2047: forge.Forge.FindSkusByIds:output_type -> forge.SkuList + 1093, // 2048: forge.Forge.UpdateSkuMetadata:output_type -> google.protobuf.Empty + 719, // 2049: forge.Forge.ReplaceSku:output_type -> forge.Sku + 403, // 2050: forge.Forge.GetManagedHostQuarantineState:output_type -> forge.GetManagedHostQuarantineStateResponse + 405, // 2051: forge.Forge.SetManagedHostQuarantineState:output_type -> forge.SetManagedHostQuarantineStateResponse + 407, // 2052: forge.Forge.ClearManagedHostQuarantineState:output_type -> forge.ClearManagedHostQuarantineStateResponse + 1093, // 2053: forge.Forge.ResetHostReprovisioning:output_type -> google.protobuf.Empty + 1093, // 2054: forge.Forge.CopyBfbToDpuRshim:output_type -> google.protobuf.Empty + 729, // 2055: forge.Forge.GetAllDpaInterfaceIds:output_type -> forge.DpaInterfaceIdList + 731, // 2056: forge.Forge.FindDpaInterfacesByIds:output_type -> forge.DpaInterfaceList + 727, // 2057: forge.Forge.CreateDpaInterface:output_type -> forge.DpaInterface + 727, // 2058: forge.Forge.EnsureDpaInterface:output_type -> forge.DpaInterface + 734, // 2059: forge.Forge.DeleteDpaInterface:output_type -> forge.DpaInterfaceDeletionResult + 739, // 2060: forge.Forge.GetPowerOptions:output_type -> forge.PowerOptionResponse + 739, // 2061: forge.Forge.UpdatePowerOption:output_type -> forge.PowerOptionResponse + 1093, // 2062: forge.Forge.AllowIngestionAndPowerOn:output_type -> google.protobuf.Empty + 129, // 2063: forge.Forge.DetermineMachineIngestionState:output_type -> forge.MachineIngestionStateResponse + 757, // 2064: forge.Forge.FindRackIds:output_type -> forge.RackIdList + 755, // 2065: forge.Forge.FindRacksByIds:output_type -> forge.RackList + 754, // 2066: forge.Forge.GetRack:output_type -> forge.GetRackResponse + 1093, // 2067: forge.Forge.DeleteRack:output_type -> google.protobuf.Empty + 765, // 2068: forge.Forge.AdminForceDeleteRack:output_type -> forge.AdminForceDeleteRackResponse + 772, // 2069: forge.Forge.GetRackProfile:output_type -> forge.GetRackProfileResponse + 743, // 2070: forge.Forge.CreateComputeAllocation:output_type -> forge.CreateComputeAllocationResponse + 745, // 2071: forge.Forge.FindComputeAllocationIds:output_type -> forge.FindComputeAllocationIdsResponse + 747, // 2072: forge.Forge.FindComputeAllocationsByIds:output_type -> forge.FindComputeAllocationsByIdsResponse + 748, // 2073: forge.Forge.UpdateComputeAllocation:output_type -> forge.UpdateComputeAllocationResponse + 751, // 2074: forge.Forge.DeleteComputeAllocation:output_type -> forge.DeleteComputeAllocationResponse + 818, // 2075: forge.Forge.SetFirmwareUpdateTimeWindow:output_type -> forge.SetFirmwareUpdateTimeWindowResponse + 827, // 2076: forge.Forge.ListHostFirmware:output_type -> forge.ListHostFirmwareResponse + 1217, // 2077: forge.Forge.PublishMlxDeviceReport:output_type -> mlx_device.PublishMlxDeviceReportResponse + 1218, // 2078: forge.Forge.PublishMlxObservationReport:output_type -> mlx_device.PublishMlxObservationReportResponse + 830, // 2079: forge.Forge.TrimTable:output_type -> forge.TrimTableResponse + 832, // 2080: forge.Forge.ListNvlinkNmxcEndpoints:output_type -> forge.NvlinkNmxcEndpointList + 831, // 2081: forge.Forge.CreateNvlinkNmxcEndpoint:output_type -> forge.NvlinkNmxcEndpoint + 831, // 2082: forge.Forge.UpdateNvlinkNmxcEndpoint:output_type -> forge.NvlinkNmxcEndpoint + 1093, // 2083: forge.Forge.DeleteNvlinkNmxcEndpoint:output_type -> google.protobuf.Empty + 835, // 2084: forge.Forge.CreateRemediation:output_type -> forge.CreateRemediationResponse + 1093, // 2085: forge.Forge.ApproveRemediation:output_type -> google.protobuf.Empty + 1093, // 2086: forge.Forge.RevokeRemediation:output_type -> google.protobuf.Empty + 1093, // 2087: forge.Forge.EnableRemediation:output_type -> google.protobuf.Empty + 1093, // 2088: forge.Forge.DisableRemediation:output_type -> google.protobuf.Empty + 836, // 2089: forge.Forge.FindRemediationIds:output_type -> forge.RemediationIdList + 837, // 2090: forge.Forge.FindRemediationsByIds:output_type -> forge.RemediationList + 844, // 2091: forge.Forge.FindAppliedRemediationIds:output_type -> forge.AppliedRemediationIdList + 847, // 2092: forge.Forge.FindAppliedRemediations:output_type -> forge.AppliedRemediationList + 849, // 2093: forge.Forge.GetNextRemediationForMachine:output_type -> forge.GetNextRemediationForMachineResponse + 1093, // 2094: forge.Forge.RemediationApplied:output_type -> google.protobuf.Empty + 1093, // 2095: forge.Forge.SetPrimaryDpu:output_type -> google.protobuf.Empty + 1093, // 2096: forge.Forge.SetPrimaryInterface:output_type -> google.protobuf.Empty + 858, // 2097: forge.Forge.CreateDpuExtensionService:output_type -> forge.DpuExtensionService + 858, // 2098: forge.Forge.UpdateDpuExtensionService:output_type -> forge.DpuExtensionService + 862, // 2099: forge.Forge.DeleteDpuExtensionService:output_type -> forge.DeleteDpuExtensionServiceResponse + 864, // 2100: forge.Forge.FindDpuExtensionServiceIds:output_type -> forge.DpuExtensionServiceIdList + 866, // 2101: forge.Forge.FindDpuExtensionServicesByIds:output_type -> forge.DpuExtensionServiceList + 868, // 2102: forge.Forge.GetDpuExtensionServiceVersionsInfo:output_type -> forge.DpuExtensionServiceVersionInfoList + 870, // 2103: forge.Forge.FindInstancesByDpuExtensionService:output_type -> forge.FindInstancesByDpuExtensionServiceResponse + 103, // 2104: forge.Forge.TriggerMachineAttestation:output_type -> forge.SpdmMachineAttestationTriggerResponse + 1093, // 2105: forge.Forge.CancelMachineAttestation:output_type -> google.protobuf.Empty + 108, // 2106: forge.Forge.ListAttestationMachines:output_type -> forge.SpdmListAttestationMachinesResponse + 105, // 2107: forge.Forge.GetAttestationMachine:output_type -> forge.SpdmGetAttestationMachineResponse + 110, // 2108: forge.Forge.SignMachineIdentity:output_type -> forge.MachineIdentityResponse + 115, // 2109: forge.Forge.GetTenantIdentityConfiguration:output_type -> forge.TenantIdentityConfigResponse + 115, // 2110: forge.Forge.SetTenantIdentityConfiguration:output_type -> forge.TenantIdentityConfigResponse + 1093, // 2111: forge.Forge.DeleteTenantIdentityConfiguration:output_type -> google.protobuf.Empty + 118, // 2112: forge.Forge.GetTokenDelegation:output_type -> forge.TokenDelegationResponse + 118, // 2113: forge.Forge.SetTokenDelegation:output_type -> forge.TokenDelegationResponse + 1093, // 2114: forge.Forge.DeleteTokenDelegation:output_type -> google.protobuf.Empty + 124, // 2115: forge.Forge.ReencryptTenantIdentitySecrets:output_type -> forge.ReencryptTenantIdentitySecretsResponse + 125, // 2116: forge.Forge.GetJWKS:output_type -> forge.Jwks + 126, // 2117: forge.Forge.GetOpenIDConfiguration:output_type -> forge.OpenIdConfiguration + 877, // 2118: forge.Forge.ScoutStream:output_type -> forge.ScoutStreamScoutBoundMessage + 880, // 2119: forge.Forge.ScoutStreamShowConnections:output_type -> forge.ScoutStreamShowConnectionsResponse + 882, // 2120: forge.Forge.ScoutStreamDisconnect:output_type -> forge.ScoutStreamDisconnectResponse + 884, // 2121: forge.Forge.ScoutStreamPing:output_type -> forge.ScoutStreamAdminPingResponse + 1219, // 2122: forge.Forge.MlxAdminProfileSync:output_type -> mlx_device.MlxAdminProfileSyncResponse + 1220, // 2123: forge.Forge.MlxAdminProfileShow:output_type -> mlx_device.MlxAdminProfileShowResponse + 1221, // 2124: forge.Forge.MlxAdminProfileCompare:output_type -> mlx_device.MlxAdminProfileCompareResponse + 1222, // 2125: forge.Forge.MlxAdminProfileList:output_type -> mlx_device.MlxAdminProfileListResponse + 1223, // 2126: forge.Forge.MlxAdminLockdownLock:output_type -> mlx_device.MlxAdminLockdownLockResponse + 1224, // 2127: forge.Forge.MlxAdminLockdownUnlock:output_type -> mlx_device.MlxAdminLockdownUnlockResponse + 1225, // 2128: forge.Forge.MlxAdminLockdownStatus:output_type -> mlx_device.MlxAdminLockdownStatusResponse + 1226, // 2129: forge.Forge.MlxAdminShowDevice:output_type -> mlx_device.MlxAdminDeviceInfoResponse + 1227, // 2130: forge.Forge.MlxAdminShowMachine:output_type -> mlx_device.MlxAdminDeviceReportResponse + 1228, // 2131: forge.Forge.MlxAdminRegistryList:output_type -> mlx_device.MlxAdminRegistryListResponse + 1229, // 2132: forge.Forge.MlxAdminRegistryShow:output_type -> mlx_device.MlxAdminRegistryShowResponse + 1230, // 2133: forge.Forge.MlxAdminConfigQuery:output_type -> mlx_device.MlxAdminConfigQueryResponse + 1231, // 2134: forge.Forge.MlxAdminConfigSet:output_type -> mlx_device.MlxAdminConfigSetResponse + 1232, // 2135: forge.Forge.MlxAdminConfigSync:output_type -> mlx_device.MlxAdminConfigSyncResponse + 1233, // 2136: forge.Forge.MlxAdminConfigCompare:output_type -> mlx_device.MlxAdminConfigCompareResponse + 795, // 2137: forge.Forge.FindNVLinkPartitionIds:output_type -> forge.NVLinkPartitionIdList + 790, // 2138: forge.Forge.FindNVLinkPartitionsByIds:output_type -> forge.NVLinkPartitionList + 790, // 2139: forge.Forge.NVLinkPartitionsForTenant:output_type -> forge.NVLinkPartitionList + 806, // 2140: forge.Forge.FindNVLinkLogicalPartitionIds:output_type -> forge.NVLinkLogicalPartitionIdList + 800, // 2141: forge.Forge.FindNVLinkLogicalPartitionsByIds:output_type -> forge.NVLinkLogicalPartitionList + 799, // 2142: forge.Forge.CreateNVLinkLogicalPartition:output_type -> forge.NVLinkLogicalPartition + 808, // 2143: forge.Forge.UpdateNVLinkLogicalPartition:output_type -> forge.NVLinkLogicalPartitionUpdateResult + 803, // 2144: forge.Forge.DeleteNVLinkLogicalPartition:output_type -> forge.NVLinkLogicalPartitionDeletionResult + 800, // 2145: forge.Forge.NVLinkLogicalPartitionsForTenant:output_type -> forge.NVLinkLogicalPartitionList + 898, // 2146: forge.Forge.GetMachinePositionInfo:output_type -> forge.MachinePositionInfoList + 788, // 2147: forge.Forge.NmxcBrowse:output_type -> forge.NmxcBrowseResponse + 1093, // 2148: forge.Forge.ModifyDPFState:output_type -> google.protobuf.Empty + 901, // 2149: forge.Forge.GetDPFState:output_type -> forge.DPFStateResponse + 904, // 2150: forge.Forge.GetDPFHostSnapshot:output_type -> forge.DPFHostSnapshotResponse + 907, // 2151: forge.Forge.GetDPFServiceVersions:output_type -> forge.DPFServiceVersionsResponse + 915, // 2152: forge.Forge.ComponentPowerControl:output_type -> forge.ComponentPowerControlResponse + 917, // 2153: forge.Forge.ComponentConfigureSwitchCertificate:output_type -> forge.ComponentConfigureSwitchCertificateResponse + 913, // 2154: forge.Forge.GetComponentInventory:output_type -> forge.GetComponentInventoryResponse + 924, // 2155: forge.Forge.UpdateComponentFirmware:output_type -> forge.UpdateComponentFirmwareResponse + 926, // 2156: forge.Forge.GetComponentFirmwareStatus:output_type -> forge.GetComponentFirmwareStatusResponse + 930, // 2157: forge.Forge.ListComponentFirmwareVersions:output_type -> forge.ListComponentFirmwareVersionsResponse + 943, // 2158: forge.Forge.CreateOperatingSystem:output_type -> forge.OperatingSystem + 943, // 2159: forge.Forge.GetOperatingSystem:output_type -> forge.OperatingSystem + 943, // 2160: forge.Forge.UpdateOperatingSystem:output_type -> forge.OperatingSystem + 949, // 2161: forge.Forge.DeleteOperatingSystem:output_type -> forge.DeleteOperatingSystemResponse + 951, // 2162: forge.Forge.FindOperatingSystemIds:output_type -> forge.OperatingSystemIdList + 953, // 2163: forge.Forge.FindOperatingSystemsByIds:output_type -> forge.OperatingSystemList + 955, // 2164: forge.Forge.GetOperatingSystemCachableIpxeTemplateArtifacts:output_type -> forge.IpxeTemplateArtifactList + 955, // 2165: forge.Forge.UpdateOperatingSystemCachableIpxeTemplateArtifacts:output_type -> forge.IpxeTemplateArtifactList + 960, // 2166: forge.Forge.ReWrapSecrets:output_type -> forge.ReWrapSecretsResponse + 1697, // [1697:2167] is the sub-list for method output_type + 1227, // [1227:1697] is the sub-list for method input_type + 1227, // [1227:1227] is the sub-list for extension type_name + 1227, // [1227:1227] is the sub-list for extension extendee + 0, // [0:1227] is the sub-list for field type_name } func init() { file_nico_nico_proto_init() } @@ -72713,128 +72815,129 @@ func file_nico_nico_proto_init() { file_nico_nico_proto_msgTypes[457].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[458].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[459].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[460].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[461].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[468].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[469].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[462].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[463].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[470].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[471].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[474].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[472].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[473].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[476].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[478].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[483].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[480].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[485].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[488].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[489].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[487].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[490].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[491].OneofWrappers = []any{ (*MachineValidationStatus_Started)(nil), (*MachineValidationStatus_InProgress)(nil), (*MachineValidationStatus_Completed)(nil), } - file_nico_nico_proto_msgTypes[490].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[494].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[498].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[502].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[503].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[506].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[492].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[496].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[500].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[504].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[505].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[508].OneofWrappers = []any{ (*MaintenanceActivityConfig_FirmwareUpgrade)(nil), (*MaintenanceActivityConfig_ConfigureNmxCluster)(nil), (*MaintenanceActivityConfig_PowerSequence)(nil), (*MaintenanceActivityConfig_NvosUpdate)(nil), } - file_nico_nico_proto_msgTypes[510].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[511].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[520].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[512].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[513].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[522].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[523].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[524].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[525].OneofWrappers = []any{ (*MachineValidationHeartbeatRequest_RunItemId)(nil), (*MachineValidationHeartbeatRequest_AttemptId)(nil), (*MachineValidationHeartbeatRequest_TestId)(nil), } - file_nico_nico_proto_msgTypes[527].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[529].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[534].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[541].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[542].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[531].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[536].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[543].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[544].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[545].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[546].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[547].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[550].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[551].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[548].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[549].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[552].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[556].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[561].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[568].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[553].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[554].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[558].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[563].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[570].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[571].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[582].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[583].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[572].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[573].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[584].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[585].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[587].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[590].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[594].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[597].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[598].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[589].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[592].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[596].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[599].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[600].OneofWrappers = []any{ (*NetworkSecurityGroupRuleAttributes_SrcPrefix)(nil), (*NetworkSecurityGroupRuleAttributes_DstPrefix)(nil), } - file_nico_nico_proto_msgTypes[611].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[615].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[616].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[621].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[624].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[625].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[632].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[635].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[638].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[639].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[613].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[617].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[618].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[623].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[626].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[627].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[634].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[637].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[640].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[641].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[646].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[650].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[653].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[663].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[664].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[643].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[648].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[652].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[655].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[665].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[670].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[671].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[674].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[675].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[666].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[667].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[672].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[673].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[676].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[677].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[679].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[683].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[689].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[690].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[698].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[701].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[704].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[681].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[685].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[691].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[692].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[700].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[703].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[706].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[708].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[710].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[712].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[716].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[714].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[718].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[719].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[720].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[721].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[735].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[740].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[746].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[753].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[722].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[723].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[737].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[742].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[748].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[755].OneofWrappers = []any{ (*DpuExtensionServiceCredential_UsernamePassword)(nil), } - file_nico_nico_proto_msgTypes[754].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[755].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[756].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[757].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[760].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[766].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[758].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[759].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[762].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[768].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[771].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[770].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[773].OneofWrappers = []any{ (*DpuExtensionServiceObservabilityConfig_Prometheus)(nil), (*DpuExtensionServiceObservabilityConfig_Logging)(nil), } - file_nico_nico_proto_msgTypes[773].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[775].OneofWrappers = []any{ (*ScoutStreamApiBoundMessage_Init)(nil), (*ScoutStreamApiBoundMessage_MlxDeviceLockdownResponse)(nil), (*ScoutStreamApiBoundMessage_MlxDeviceProfileSyncResponse)(nil), @@ -72849,7 +72952,7 @@ func file_nico_nico_proto_init() { (*ScoutStreamApiBoundMessage_MlxDeviceConfigCompareResponse)(nil), (*ScoutStreamApiBoundMessage_ScoutStreamAgentPingResponse)(nil), } - file_nico_nico_proto_msgTypes[774].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[776].OneofWrappers = []any{ (*ScoutStreamScoutBoundMessage_MlxDeviceLockdownLockRequest)(nil), (*ScoutStreamScoutBoundMessage_MlxDeviceLockdownUnlockRequest)(nil), (*ScoutStreamScoutBoundMessage_MlxDeviceLockdownStatusRequest)(nil), @@ -72865,84 +72968,84 @@ func file_nico_nico_proto_init() { (*ScoutStreamScoutBoundMessage_MlxDeviceConfigCompareRequest)(nil), (*ScoutStreamScoutBoundMessage_ScoutStreamAgentPingRequest)(nil), } - file_nico_nico_proto_msgTypes[783].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[785].OneofWrappers = []any{ (*ScoutStreamAgentPingResponse_Pong)(nil), (*ScoutStreamAgentPingResponse_Error)(nil), } - file_nico_nico_proto_msgTypes[792].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[793].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[794].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[795].OneofWrappers = []any{ (*PxeDomain_NewDomain)(nil), (*PxeDomain_LegacyDomain)(nil), } - file_nico_nico_proto_msgTypes[796].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[808].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[798].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[810].OneofWrappers = []any{ (*GetComponentInventoryRequest_MachineIds)(nil), (*GetComponentInventoryRequest_SwitchIds)(nil), (*GetComponentInventoryRequest_PowerShelfIds)(nil), } - file_nico_nico_proto_msgTypes[809].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[811].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[811].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[813].OneofWrappers = []any{ (*ComponentPowerControlRequest_MachineIds)(nil), (*ComponentPowerControlRequest_SwitchIds)(nil), (*ComponentPowerControlRequest_PowerShelfIds)(nil), } - file_nico_nico_proto_msgTypes[813].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[820].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[815].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[822].OneofWrappers = []any{ (*UpdateComponentFirmwareRequest_ComputeTrays)(nil), (*UpdateComponentFirmwareRequest_Switches)(nil), (*UpdateComponentFirmwareRequest_PowerShelves)(nil), (*UpdateComponentFirmwareRequest_Racks)(nil), } - file_nico_nico_proto_msgTypes[822].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[824].OneofWrappers = []any{ (*GetComponentFirmwareStatusRequest_MachineIds)(nil), (*GetComponentFirmwareStatusRequest_SwitchIds)(nil), (*GetComponentFirmwareStatusRequest_PowerShelfIds)(nil), (*GetComponentFirmwareStatusRequest_RackIds)(nil), } - file_nico_nico_proto_msgTypes[824].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[826].OneofWrappers = []any{ (*ListComponentFirmwareVersionsRequest_MachineIds)(nil), (*ListComponentFirmwareVersionsRequest_SwitchIds)(nil), (*ListComponentFirmwareVersionsRequest_PowerShelfIds)(nil), (*ListComponentFirmwareVersionsRequest_RackIds)(nil), } - file_nico_nico_proto_msgTypes[828].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[833].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[840].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[841].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[844].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[847].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[853].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[856].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[859].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[860].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[830].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[835].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[842].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[843].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[846].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[849].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[855].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[858].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[861].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[862].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[863].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[864].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[869].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[866].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[871].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[876].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[873].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[878].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[894].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[896].OneofWrappers = []any{ + file_nico_nico_proto_msgTypes[880].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[896].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[898].OneofWrappers = []any{ (*ForgeAgentControlResponse_MlxDeviceAction_Noop)(nil), (*ForgeAgentControlResponse_MlxDeviceAction_Lock)(nil), (*ForgeAgentControlResponse_MlxDeviceAction_Unlock)(nil), (*ForgeAgentControlResponse_MlxDeviceAction_ApplyProfile)(nil), (*ForgeAgentControlResponse_MlxDeviceAction_ApplyFirmware)(nil), } - file_nico_nico_proto_msgTypes[900].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[901].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[905].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[906].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[902].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[903].OneofWrappers = []any{} file_nico_nico_proto_msgTypes[907].OneofWrappers = []any{} - file_nico_nico_proto_msgTypes[914].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[908].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[909].OneofWrappers = []any{} + file_nico_nico_proto_msgTypes[916].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_nico_nico_proto_rawDesc), len(file_nico_nico_proto_rawDesc)), NumEnums: 101, - NumMessages: 915, + NumMessages: 917, NumExtensions: 0, NumServices: 1, }, diff --git a/rest-api/proto/core/gen/v1/nico_nico_grpc.pb.go b/rest-api/proto/core/gen/v1/nico_nico_grpc.pb.go index 09e2bbc7ff..7e2146e0e9 100644 --- a/rest-api/proto/core/gen/v1/nico_nico_grpc.pb.go +++ b/rest-api/proto/core/gen/v1/nico_nico_grpc.pb.go @@ -216,6 +216,7 @@ const ( Forge_UpdateInstancePhoneHomeLastContact_FullMethodName = "/forge.Forge/UpdateInstancePhoneHomeLastContact" Forge_SetHostUefiPassword_FullMethodName = "/forge.Forge/SetHostUefiPassword" Forge_ClearHostUefiPassword_FullMethodName = "/forge.Forge/ClearHostUefiPassword" + Forge_SetDpuUefiPassword_FullMethodName = "/forge.Forge/SetDpuUefiPassword" Forge_AddExpectedMachine_FullMethodName = "/forge.Forge/AddExpectedMachine" Forge_DeleteExpectedMachine_FullMethodName = "/forge.Forge/DeleteExpectedMachine" Forge_UpdateExpectedMachine_FullMethodName = "/forge.Forge/UpdateExpectedMachine" @@ -854,6 +855,10 @@ type ForgeClient interface { // Set Host UEFI password SetHostUefiPassword(ctx context.Context, in *SetHostUefiPasswordRequest, opts ...grpc.CallOption) (*SetHostUefiPasswordResponse, error) ClearHostUefiPassword(ctx context.Context, in *ClearHostUefiPasswordRequest, opts ...grpc.CallOption) (*ClearHostUefiPasswordResponse, error) + // Set a DPU's UEFI password directly on the device (the DPU equivalent of + // SetHostUefiPassword): stage the site-wide DPU UEFI credential through the + // DPU's Redfish BIOS settings and restart the DPU to commit it. + SetDpuUefiPassword(ctx context.Context, in *SetDpuUefiPasswordRequest, opts ...grpc.CallOption) (*SetDpuUefiPasswordResponse, error) // Expected Machine Management // Add expected machine AddExpectedMachine(ctx context.Context, in *ExpectedMachine, opts ...grpc.CallOption) (*emptypb.Empty, error) @@ -3270,6 +3275,16 @@ func (c *forgeClient) ClearHostUefiPassword(ctx context.Context, in *ClearHostUe return out, nil } +func (c *forgeClient) SetDpuUefiPassword(ctx context.Context, in *SetDpuUefiPasswordRequest, opts ...grpc.CallOption) (*SetDpuUefiPasswordResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SetDpuUefiPasswordResponse) + err := c.cc.Invoke(ctx, Forge_SetDpuUefiPassword_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *forgeClient) AddExpectedMachine(ctx context.Context, in *ExpectedMachine, opts ...grpc.CallOption) (*emptypb.Empty, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(emptypb.Empty) @@ -6393,6 +6408,10 @@ type ForgeServer interface { // Set Host UEFI password SetHostUefiPassword(context.Context, *SetHostUefiPasswordRequest) (*SetHostUefiPasswordResponse, error) ClearHostUefiPassword(context.Context, *ClearHostUefiPasswordRequest) (*ClearHostUefiPasswordResponse, error) + // Set a DPU's UEFI password directly on the device (the DPU equivalent of + // SetHostUefiPassword): stage the site-wide DPU UEFI credential through the + // DPU's Redfish BIOS settings and restart the DPU to commit it. + SetDpuUefiPassword(context.Context, *SetDpuUefiPasswordRequest) (*SetDpuUefiPasswordResponse, error) // Expected Machine Management // Add expected machine AddExpectedMachine(context.Context, *ExpectedMachine) (*emptypb.Empty, error) @@ -7450,6 +7469,9 @@ func (UnimplementedForgeServer) SetHostUefiPassword(context.Context, *SetHostUef func (UnimplementedForgeServer) ClearHostUefiPassword(context.Context, *ClearHostUefiPasswordRequest) (*ClearHostUefiPasswordResponse, error) { return nil, status.Error(codes.Unimplemented, "method ClearHostUefiPassword not implemented") } +func (UnimplementedForgeServer) SetDpuUefiPassword(context.Context, *SetDpuUefiPasswordRequest) (*SetDpuUefiPasswordResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SetDpuUefiPassword not implemented") +} func (UnimplementedForgeServer) AddExpectedMachine(context.Context, *ExpectedMachine) (*emptypb.Empty, error) { return nil, status.Error(codes.Unimplemented, "method AddExpectedMachine not implemented") } @@ -11772,6 +11794,24 @@ func _Forge_ClearHostUefiPassword_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } +func _Forge_SetDpuUefiPassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetDpuUefiPasswordRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServer).SetDpuUefiPassword(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Forge_SetDpuUefiPassword_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServer).SetDpuUefiPassword(ctx, req.(*SetDpuUefiPasswordRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Forge_AddExpectedMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExpectedMachine) if err := dec(in); err != nil { @@ -17508,6 +17548,10 @@ var Forge_ServiceDesc = grpc.ServiceDesc{ MethodName: "ClearHostUefiPassword", Handler: _Forge_ClearHostUefiPassword_Handler, }, + { + MethodName: "SetDpuUefiPassword", + Handler: _Forge_SetDpuUefiPassword_Handler, + }, { MethodName: "AddExpectedMachine", Handler: _Forge_AddExpectedMachine_Handler, diff --git a/rest-api/proto/core/src/v1/nico_nico.proto b/rest-api/proto/core/src/v1/nico_nico.proto index ae6d6e20b3..1bf5b55c63 100644 --- a/rest-api/proto/core/src/v1/nico_nico.proto +++ b/rest-api/proto/core/src/v1/nico_nico.proto @@ -454,6 +454,11 @@ service Forge { rpc SetHostUefiPassword(SetHostUefiPasswordRequest) returns (SetHostUefiPasswordResponse); rpc ClearHostUefiPassword(ClearHostUefiPasswordRequest) returns (ClearHostUefiPasswordResponse); + // Set a DPU's UEFI password directly on the device (the DPU equivalent of + // SetHostUefiPassword): stage the site-wide DPU UEFI credential through the + // DPU's Redfish BIOS settings and restart the DPU to commit it. + rpc SetDpuUefiPassword(SetDpuUefiPasswordRequest) returns (SetDpuUefiPasswordResponse); + // Expected Machine Management // Add expected machine rpc AddExpectedMachine(ExpectedMachine) returns (google.protobuf.Empty); @@ -6199,6 +6204,19 @@ message ClearHostUefiPasswordResponse { optional string job_id = 1; } +message SetDpuUefiPasswordRequest { + // The DPU machine to set the UEFI password on. + common.MachineId dpu_id = 1; + // UUID, IP address, hostname or MAC address resolving to the DPU machine + // (preferred over dpu_id). + optional string machine_query = 2; +} + +message SetDpuUefiPasswordResponse { + // A DPU stages the change through Redfish BIOS settings and schedules no job, + // so there is nothing to poll and no job id is returned. +} + enum OsImageStatus { // default status when entry created ImageUninitialized = 0; From 4fe82eaaa6cfd2b41dcafe20288551d7ba634e1c Mon Sep 17 00:00:00 2001 From: Ivan Anisimov Date: Mon, 10 Aug 2026 14:55:33 -0700 Subject: [PATCH 11/26] Cherry pick/nv redfish 0.14 to v2.1 (#4785) Cherry pick #4705 and #4776 Fixes issues with SSE logs collectors. --------- Signed-off-by: ianisimov --- Cargo.lock | 20 +++++++++---------- Cargo.toml | 3 ++- crates/bmc-explorer/Cargo.toml | 3 +-- crates/bmc-explorer/src/chassis.rs | 6 +----- crates/bmc-explorer/src/computer_system.rs | 6 +++--- .../health/src/collectors/entity_metrics.rs | 4 ++-- 6 files changed, 19 insertions(+), 23 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 681be9a661..32f10bd2e3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7791,9 +7791,9 @@ dependencies = [ [[package]] name = "nv-redfish" -version = "0.12.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2592edb56672a2c7edf127a376cc1ee487ba0e3c6f1de089e0a8074e731fae2c" +checksum = "42762fc262b81359c6f05cb8b6bdd7d42d9fee3210a1680885b2376a9f9911ec" dependencies = [ "futures-core", "futures-util", @@ -7808,9 +7808,9 @@ dependencies = [ [[package]] name = "nv-redfish-bmc-http" -version = "0.12.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36d20f59e47169c5adc5ee4d16ee58c4be04bdb7b13adf20c95b574b068f2d65" +checksum = "bed037619507a81fe1b241e04414f9562a8da41b6774c13df55a9330644117af" dependencies = [ "bytes", "futures-core", @@ -7833,9 +7833,9 @@ dependencies = [ [[package]] name = "nv-redfish-core" -version = "0.12.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d604b8acdfb20dae81b2a0849258126723f649d772e5097c75a54bd75aad53e6" +checksum = "566a75a8c7d75b0d8e24289e2d8c9792ed102ede29ab7a4996510c90b21a3fce" dependencies = [ "futures-core", "futures-io", @@ -7848,9 +7848,9 @@ dependencies = [ [[package]] name = "nv-redfish-csdl-compiler" -version = "0.12.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1b4cbe1798dd45c668d35da308da62fc55e1c321e337685bd2126fc50ba07f1" +checksum = "5838f179f001a8250aa08ae69abac660e8d29f2dd8041fa5806579b64b1b734c" dependencies = [ "clap", "clap_derive", @@ -7866,9 +7866,9 @@ dependencies = [ [[package]] name = "nv-redfish-schema" -version = "0.12.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6005f1c3630b8ef4df0a2564fb935a659ae6384a09bd2c7e2081ce20e5033e15" +checksum = "eccdaff625f93aa51bd52880bbabdfd43323f75224238a4a85f5f9eefdbf2b78" dependencies = [ "glob", ] diff --git a/Cargo.toml b/Cargo.toml index 6eaa86c4b1..fae5ff86f1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -61,7 +61,8 @@ opentelemetry-semantic-conventions = "0.32.1" tracing-opentelemetry = "0.33.0" # NV-Redfish -nv-redfish = { version = "0.12.1" } +nv-redfish = { version = "0.14.2" } +nv-redfish-dispatcher = { version = "0.14.2" } ######## # MARK: - Pinned packages that we can't upgrade due to conflicts or just bugs diff --git a/crates/bmc-explorer/Cargo.toml b/crates/bmc-explorer/Cargo.toml index 6bc238f440..8696888acb 100644 --- a/crates/bmc-explorer/Cargo.toml +++ b/crates/bmc-explorer/Cargo.toml @@ -54,8 +54,7 @@ nv-redfish = { workspace = true, features = [ "power-supplies", "update-service", "secure-boot", - "oem-nvidia-bluefield", - "oem-nvidia-baseboard", + "oem-nvidia", "oem-dell-attributes", "oem-lenovo", "oem-supermicro", diff --git a/crates/bmc-explorer/src/chassis.rs b/crates/bmc-explorer/src/chassis.rs index de6075c71a..7361fada84 100644 --- a/crates/bmc-explorer/src/chassis.rs +++ b/crates/bmc-explorer/src/chassis.rs @@ -430,11 +430,7 @@ impl ExploredChassis { .or(hw_id.serial_number.map(|v| v.to_string())) .map(|s| s.trim().to_string()); - let nvidia_oem = self - .chassis - .oem_nvidia_baseboard_cbc() - .ok() - .and_then(identity); + let nvidia_oem = self.chassis.oem_nvidia_cbc().ok().and_then(identity); Chassis { id: chassis_id.to_string(), manufacturer: hw_id.manufacturer.map(|v| v.to_string()), diff --git a/crates/bmc-explorer/src/computer_system.rs b/crates/bmc-explorer/src/computer_system.rs index 641215538e..b5e942d022 100644 --- a/crates/bmc-explorer/src/computer_system.rs +++ b/crates/bmc-explorer/src/computer_system.rs @@ -31,7 +31,7 @@ use nv_redfish::computer_system::{ Bios, BootOption, ComputerSystem, SecureBoot, SecureBootCurrentBootType, }; use nv_redfish::ethernet_interface::{EthernetInterface, UefiDevicePath as EthUefiDevicePath}; -use nv_redfish::oem::nvidia::bluefield::NvidiaComputerSystem; +use nv_redfish::oem::nvidia::NvidiaComputerSystem; use nv_redfish::pcie_device::PcieDevice; use nv_redfish::resource::PowerState; use nv_redfish::{Bmc, Resource, ResourceProvidesStatus}; @@ -94,7 +94,7 @@ impl ExploredComputerSystem { let oem_nvidia_bluefield = if config.need_oem_nvidia_bluefield { system - .oem_nvidia_bluefield() + .oem_nvidia() .await .map_err(Error::nv_redfish("NVIDIA system Bluefield OEM"))? } else { @@ -501,7 +501,7 @@ impl ExploredComputerSystem { | Some("Bluefield 3 DPU") | Some("BlueField-3 SmartNIC Main Card") | Some("Bluefield 3 SmartNIC Main Card") => { - use nv_redfish::oem::nvidia::bluefield::nvidia_computer_system::Mode; + use nv_redfish::oem::nvidia::computer_system::Mode; bf_ncs.mode().and_then(|v| match v { Mode::DpuMode => Some(BlueFieldOperatingMode::Dpu), Mode::NicMode => Some(BlueFieldOperatingMode::Nic), diff --git a/crates/health/src/collectors/entity_metrics.rs b/crates/health/src/collectors/entity_metrics.rs index badffe4869..45da68b44a 100644 --- a/crates/health/src/collectors/entity_metrics.rs +++ b/crates/health/src/collectors/entity_metrics.rs @@ -460,13 +460,13 @@ impl MetricsCollector { let fields = match entity { DiscoveredEntity::Processor { entity, .. } => { match self.fetch(entity.metrics().await, "processor metrics", fetch_failures) { - Some(Some(m)) => processor_metric_fields(&m), + Some(Some(m)) => processor_metric_fields(&m.raw()), _ => return 0, } } DiscoveredEntity::Memory { entity, .. } => { match self.fetch(entity.metrics().await, "memory metrics", fetch_failures) { - Some(Some(m)) => memory_metric_fields(&m), + Some(Some(m)) => memory_metric_fields(&m.raw()), _ => return 0, } } From adaf327fe007f2f9637e8a633886932d38a3b1a5 Mon Sep 17 00:00:00 2001 From: Drew Bloechl Date: Mon, 10 Aug 2026 15:43:44 -0700 Subject: [PATCH 12/26] fix(nvue-client): Add polling in NvueClient::apply_config_revision (#4791) This is a backport to v2.1 of #4729 (which the following text is from). I've been overly optimistic in `NvueClient::apply_config_revision()`, assuming that we don't need to care about checking the state of the revision we just applied. QA found a bug (tracked internally as NVbugs 6563638) that suggests this was a mistake. This branch adds polling logic in `apply_config_revision()`, with parsing of the revision data derived from the OpenAPI spec from NVUE in Cumulus Linux 5.16.0 (the most recent version I had handy). ## Related issues - NVbugs 6563638 ## Type of Change - [ ] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [X] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [X] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) ## Additional Notes --- Cargo.lock | 1 + crates/nvue-client/Cargo.toml | 1 + crates/nvue-client/src/client.rs | 88 ++++++- crates/nvue-client/src/lib.rs | 12 +- crates/nvue-client/src/types/mod.rs | 10 + crates/nvue-client/src/types/revision.rs | 298 +++++++++++++++++++++++ 6 files changed, 396 insertions(+), 14 deletions(-) create mode 100644 crates/nvue-client/src/types/mod.rs create mode 100644 crates/nvue-client/src/types/revision.rs diff --git a/Cargo.lock b/Cargo.lock index 32f10bd2e3..904779d098 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7884,6 +7884,7 @@ dependencies = [ "serde_json", "serde_yaml", "thiserror 2.0.18", + "tokio", ] [[package]] diff --git a/crates/nvue-client/Cargo.toml b/crates/nvue-client/Cargo.toml index f8935bf42a..f5c11f00dc 100644 --- a/crates/nvue-client/Cargo.toml +++ b/crates/nvue-client/Cargo.toml @@ -35,6 +35,7 @@ serde = { features = ["derive"], workspace = true } serde_json = { workspace = true } serde_yaml = { workspace = true } thiserror = { workspace = true } +tokio = { workspace = true } [dev-dependencies] glob = { workspace = true } diff --git a/crates/nvue-client/src/client.rs b/crates/nvue-client/src/client.rs index f7ee81cc7b..11317f629b 100644 --- a/crates/nvue-client/src/client.rs +++ b/crates/nvue-client/src/client.rs @@ -17,6 +17,7 @@ use std::collections::{BTreeMap, HashMap}; use std::path::PathBuf; +use std::time::Duration; use carbide_instrument::red; use reqwest::header::{ACCEPT, HeaderMap, HeaderValue}; @@ -24,6 +25,7 @@ use reqwest::{Client, ClientBuilder, Method, Response, Url}; pub use serde_json::Value as JsonValue; use crate::config::{NvueConfig, NvueConfigWithHeader, NvueRevision}; +use crate::types::revision::{RevisionApplyStatus, RevisionData, RevisionIssueSummary}; #[derive(Debug)] pub struct NvueClient { @@ -32,6 +34,13 @@ pub struct NvueClient { } impl NvueClient { + // In the past, we've seen calls to `nv config apply` take a long time, to + // the point where the timeout for that code path (outside this crate) was + // raised to 45s. We don't know for sure that we need the same budget here, + // but let's assume we do. -drew + const APPLY_CONFIG_REVISION_TIMEOUT: Duration = Duration::from_secs(45); + const APPLY_CONFIG_REVISION_POLL_INTERVAL: Duration = Duration::from_secs(1); + pub fn new(server_address: NvueServerAddress) -> Result { build_client(&server_address).map(|client| Self { server_address, @@ -132,6 +141,20 @@ impl NvueClient { Ok(revision_id) } + /// Return data about the specified revision. + pub async fn get_revision(&self, revision_id: &str) -> Result { + let revision_path = format!("/nvue_v1/revision/{revision_id}"); + let request = self.request(Method::GET, &revision_path)?.build()?; + let response = self.execute("get_revision", request).await?; + + // For some reason, the NVUE schema allows the response to be nulled, + // but as far as we're concerned that's an error. + let revision_data: Option<_> = response.json().await?; + revision_data.ok_or(NvueClientError::SchemaMismatch( + "revision response was null", + )) + } + /// Replace the specified config revision. Under the hood, this is a /// two-stage operation where the configuration is deleted and then new /// values are inserted. @@ -163,9 +186,42 @@ impl NvueClient { let request = builder.build()?; let _response = self.execute("apply_config_revision", request).await?; - // FIXME: we should poll on the revision path until it reaches an - // "applied" state - Ok(()) + let started = tokio::time::Instant::now(); + let deadline = started + Self::APPLY_CONFIG_REVISION_TIMEOUT; + + loop { + let revision = self.get_revision(revision_id).await?; + + let now = tokio::time::Instant::now(); + let remaining = deadline.checked_duration_since(now); + + match (revision.apply_status(), remaining) { + (RevisionApplyStatus::Applied, _) => break Ok(()), + (RevisionApplyStatus::Failed(error_issues), _) => { + break Err(NvueClientError::RevisionApplyFailed { + revision_id: revision_id.to_owned(), + reason: RevisionApplyFailureReason::Error, + last_state: revision.state.clone(), + progress: revision.transition_progress().map(String::from), + error_issues, + }); + } + (RevisionApplyStatus::Pending, Some(remaining)) => { + tokio::time::sleep(remaining.min(Self::APPLY_CONFIG_REVISION_POLL_INTERVAL)) + .await; + } + (RevisionApplyStatus::Pending, None) => { + let elapsed = now - started; + break Err(NvueClientError::RevisionApplyFailed { + revision_id: revision_id.to_owned(), + reason: RevisionApplyFailureReason::Timeout { waited: elapsed }, + last_state: revision.state.clone(), + progress: revision.transition_progress().map(String::from), + error_issues: Vec::new(), + }); + } + } + } } /// Create a new configuration using the values from `config`, then apply @@ -341,6 +397,32 @@ pub enum NvueClientError { #[error("schema mismatch between NVUE client and server: {0}")] SchemaMismatch(&'static str), + + #[error( + "NVUE revision apply failed: revision_id={revision_id}, reason={reason}, last_state={last_state:?}, progress={progress:?}, error_issues={error_issues:?}" + )] + RevisionApplyFailed { + revision_id: String, + reason: RevisionApplyFailureReason, + last_state: Option, + progress: Option, + error_issues: Vec, + }, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum RevisionApplyFailureReason { + Error, + Timeout { waited: Duration }, +} + +impl std::fmt::Display for RevisionApplyFailureReason { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Error => f.write_str("error"), + Self::Timeout { waited } => write!(f, "timeout after {waited:?}"), + } + } } #[derive(thiserror::Error, Debug)] diff --git a/crates/nvue-client/src/lib.rs b/crates/nvue-client/src/lib.rs index f97b0a82ce..3408925edf 100644 --- a/crates/nvue-client/src/lib.rs +++ b/crates/nvue-client/src/lib.rs @@ -17,17 +17,7 @@ pub mod client; pub mod config; +pub mod types; pub use client::NvueClient; pub use config::NvueConfig; - -pub mod types { - #[derive(Debug, serde::Deserialize)] - #[serde(rename_all = "kebab-case")] - pub struct MacTableEntry { - pub mac: String, - pub interface: String, - pub entry_type: String, - pub vlan: Option, - } -} diff --git a/crates/nvue-client/src/types/mod.rs b/crates/nvue-client/src/types/mod.rs new file mode 100644 index 0000000000..73f015d266 --- /dev/null +++ b/crates/nvue-client/src/types/mod.rs @@ -0,0 +1,10 @@ +pub mod revision; + +#[derive(Debug, serde::Deserialize)] +#[serde(rename_all = "kebab-case")] +pub struct MacTableEntry { + pub mac: String, + pub interface: String, + pub entry_type: String, + pub vlan: Option, +} diff --git a/crates/nvue-client/src/types/revision.rs b/crates/nvue-client/src/types/revision.rs new file mode 100644 index 0000000000..e8a9a0a936 --- /dev/null +++ b/crates/nvue-client/src/types/revision.rs @@ -0,0 +1,298 @@ +use std::collections::BTreeMap; + +use serde_json::Value as JsonValue; + +#[derive(Clone, Debug, serde::Deserialize)] +#[serde(rename_all = "kebab-case")] +pub struct RevisionData { + pub message: Option, + pub state: Option, + pub transition: Option, + pub last_apply: Option, + pub additional_data: Option, + pub auto_prompt: Option, + pub state_controls: Option, +} + +impl RevisionData { + pub(crate) fn apply_status(&self) -> RevisionApplyStatus { + let error_issues = self.error_issue_summaries(); + if !error_issues.is_empty() { + return RevisionApplyStatus::Failed(error_issues); + } + + if self.state.as_deref() == Some("applied") { + return RevisionApplyStatus::Applied; + } + + RevisionApplyStatus::Pending + } + + pub(crate) fn transition_progress(&self) -> Option<&str> { + self.transition + .as_ref() + .and_then(|transition| transition.progress.as_deref()) + } + + pub(crate) fn error_issue_summaries(&self) -> Vec { + self.transition + .as_ref() + .and_then(|transition| transition.issue.as_ref()) + .into_iter() + .flat_map(|issues| issues.iter()) + .filter(|(_, issue)| issue.severity == Some(RevisionIssueSeverity::Error)) + .map(|(issue_id, issue)| RevisionIssueSummary { + issue_id: issue_id.clone(), + severity: RevisionIssueSeverity::Error, + code: issue.code.clone(), + message: issue.message.clone(), + data: issue.data.clone(), + }) + .collect() + } +} + +#[derive(Clone, Debug, Eq, PartialEq)] +// Note that this doesn't exactly model the `status` field of an NVUE revision, +// despite some resemblance in the variant names. +pub(crate) enum RevisionApplyStatus { + Applied, + Pending, + Failed(Vec), +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct RevisionIssueSummary { + pub issue_id: String, + pub severity: RevisionIssueSeverity, + pub code: Option, + pub message: Option, + pub data: Option>, +} + +#[derive(Clone, Debug, serde::Deserialize)] +#[serde(rename_all = "kebab-case")] +pub struct RevisionTransition { + pub progress: Option, + pub issue: Option>, +} + +#[derive(Clone, Debug, serde::Deserialize)] +#[serde(rename_all = "kebab-case")] +pub struct RevisionIssue { + pub severity: Option, + pub code: Option, + pub message: Option, + pub data: Option>, +} + +#[derive(Clone, Copy, Debug, serde::Deserialize, Eq, PartialEq)] +#[serde(rename_all = "lowercase")] +pub enum RevisionIssueSeverity { + Error, + Warning, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn classifies_revision_apply_status() { + struct Case { + name: &'static str, + revision: RevisionData, + expected_status: RevisionApplyStatus, + expected_progress: Option<&'static str>, + } + + let cases = [ + Case { + name: "applied revision without issues succeeds", + revision: revision(Some("applied"), None, vec![]), + expected_status: RevisionApplyStatus::Applied, + expected_progress: None, + }, + Case { + name: "applying revision without issues remains pending", + revision: revision(Some("apply"), Some("checking"), vec![]), + expected_status: RevisionApplyStatus::Pending, + expected_progress: Some("checking"), + }, + Case { + name: "unknown state without issues remains pending", + revision: revision(Some("unknown"), None, vec![]), + expected_status: RevisionApplyStatus::Pending, + expected_progress: None, + }, + Case { + name: "missing state without issues remains pending", + revision: revision(None, None, vec![]), + expected_status: RevisionApplyStatus::Pending, + expected_progress: None, + }, + Case { + name: "warning-only issues remain pending", + revision: revision( + Some("apply"), + Some("validating"), + vec![( + "1", + issue( + RevisionIssueSeverity::Warning, + Some("sample-warning"), + Some("sample warning"), + None, + ), + )], + ), + expected_status: RevisionApplyStatus::Pending, + expected_progress: Some("validating"), + }, + Case { + name: "error issue fails with issue summary", + revision: revision( + Some("apply"), + Some("failed"), + vec![( + "2", + issue( + RevisionIssueSeverity::Error, + Some("sample-error"), + Some("sample error"), + Some(BTreeMap::from([( + "path".to_string(), + "/system".to_string(), + )])), + ), + )], + ), + expected_status: RevisionApplyStatus::Failed(vec![RevisionIssueSummary { + issue_id: "2".to_string(), + severity: RevisionIssueSeverity::Error, + code: Some("sample-error".to_string()), + message: Some("sample error".to_string()), + data: Some(BTreeMap::from([( + "path".to_string(), + "/system".to_string(), + )])), + }]), + expected_progress: Some("failed"), + }, + ]; + + for case in cases { + assert_eq!( + case.revision.apply_status(), + case.expected_status, + "{}", + case.name + ); + assert_eq!( + case.revision.transition_progress(), + case.expected_progress, + "{}", + case.name + ); + } + } + + fn revision( + state: Option<&str>, + progress: Option<&str>, + issues: Vec<(&str, RevisionIssue)>, + ) -> RevisionData { + RevisionData { + message: None, + state: state.map(str::to_owned), + transition: Some(RevisionTransition { + progress: progress.map(str::to_owned), + issue: (!issues.is_empty()).then(|| { + issues + .into_iter() + .map(|(issue_id, issue)| (issue_id.to_string(), issue)) + .collect() + }), + }), + last_apply: None, + additional_data: None, + auto_prompt: None, + state_controls: None, + } + } + + fn issue( + severity: RevisionIssueSeverity, + code: Option<&str>, + message: Option<&str>, + data: Option>, + ) -> RevisionIssue { + RevisionIssue { + severity: Some(severity), + code: code.map(str::to_owned), + message: message.map(str::to_owned), + data, + } + } + + #[test] + fn parses_revision_data_with_transition_issue() { + let json = r#" + { + "additional-data": { + "parent-revision-id": "applied" + }, + "auto-prompt": { + "ays": "ays_yes" + }, + "last-apply": { + "apply-id": "rev_1_apply_1" + }, + "message": "apply config", + "state": "apply", + "state-controls": { + "apply-type": "API" + }, + "transition": { + "progress": "checking", + "issue": { + "1": { + "severity": "warning", + "code": "sample-warning", + "message": "sample warning", + "data": { + "path": "/system" + } + } + } + } + } + "#; + + let revision: RevisionData = serde_json::from_str(json).expect("revision should parse"); + + assert_eq!(revision.message.as_deref(), Some("apply config")); + assert_eq!(revision.state.as_deref(), Some("apply")); + assert!(revision.additional_data.is_some()); + assert!(revision.auto_prompt.is_some()); + assert!(revision.last_apply.is_some()); + assert!(revision.state_controls.is_some()); + + let transition = revision.transition.expect("transition should parse"); + assert_eq!(transition.progress.as_deref(), Some("checking")); + + let issues = transition.issue.expect("issues should parse"); + let issue = issues.get("1").expect("issue should parse"); + assert_eq!(issue.severity, Some(RevisionIssueSeverity::Warning)); + assert_eq!(issue.code.as_deref(), Some("sample-warning")); + assert_eq!(issue.message.as_deref(), Some("sample warning")); + assert_eq!( + issue + .data + .as_ref() + .and_then(|data| data.get("path")) + .map(String::as_str), + Some("/system") + ); + } +} From 4e2adf2f5465fa40d353219a3eba27b15592ae8a Mon Sep 17 00:00:00 2001 From: Tareque Hossain Date: Mon, 10 Aug 2026 18:22:25 -0700 Subject: [PATCH 13/26] patch(v2.1): Disable REST Docker build CI cache export to reduce churn (#4802) `release/v2.1` pipeline runs are exporting REST images to GitHub Action cache, filling it up and evicting crucial cache. This PR brings aligns caching strategy with `main` ## Type of Change - [x] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [x] No testing required (docs, internal refactor, etc.) --- .github/workflows/rest-build-push-service.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/rest-build-push-service.yml b/.github/workflows/rest-build-push-service.yml index 4e424ab8a6..389beee4ed 100644 --- a/.github/workflows/rest-build-push-service.yml +++ b/.github/workflows/rest-build-push-service.yml @@ -174,7 +174,13 @@ jobs: CARBIDE_BUILD_HELM_VERSION=${{ inputs.helm_version }} tags: ${{ steps.docker-tags.outputs.arch_tag }} cache-from: type=gha,scope=${{ inputs.service_name }}-${{ matrix.arch }} - cache-to: type=gha,mode=max,scope=${{ inputs.service_name }}-${{ matrix.arch }} + # Nothing on this branch exports. Actions cache entries are ref-scoped, + # so every cherry-pick pull request and every release tag wrote its own + # mode=max copy of ten services on two architectures: 18.3 GB from one + # pull request and 9.1 GB from the v2.1.0-rc.2 tag, in a 150 GB pool + # shared with main. A release branch may read the default branch's + # entries, so cache-from above still starts these builds warm. + cache-to: '' labels: | org.opencontainers.image.title=${{ inputs.service_name }} org.opencontainers.image.version=${{ inputs.semantic_version }} From 1980a65d00581b8e31b73cdfba55c2424e38239f Mon Sep 17 00:00:00 2001 From: spydaNVIDIA Date: Tue, 11 Aug 2026 09:35:58 -0700 Subject: [PATCH 14/26] fix(api-db): restore migration comments to fix upgrade checksum mismatch (#4812) ## Related issues ## Type of Change - [ ] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [x] **Fix** - Bug fixes - [ ] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) ## Breaking Changes - [ ] **This PR contains breaking changes** ## Testing - [ ] Unit tests added/updated - [ ] Integration tests added/updated - [x] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) ## Additional Notes --- .../20260717120004_bmc_credential_rotation_requested.sql | 2 +- .../20260729120000_switch_bmc_credential_rotation_requested.sql | 2 +- ...0730120001_power_shelf_bmc_credential_rotation_requested.sql | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql b/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql index bb91397293..c67190adca 100644 --- a/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql +++ b/crates/api-db/migrations/20260717120004_bmc_credential_rotation_requested.sql @@ -1,6 +1,6 @@ -- Add bmc_credential_rotation_requested column to machines table. -- bmc_credential_rotation_requested: an operator "force-converge this BMC now" --- escape hatch. Set on the machine that owns the BMC (a host machine for +-- escape hatch (REQ-2). Set on the machine that owns the BMC (a host machine for -- its host BMC, a DPU machine for its DPU BMC). When true, the machine state -- controller enters RotatingBmc for the managed host and force-converges that -- machine's single BMC, bypassing the passive site-wide gate and the device's diff --git a/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql b/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql index dfa4d0afb1..714a6ebde7 100644 --- a/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql +++ b/crates/api-db/migrations/20260729120000_switch_bmc_credential_rotation_requested.sql @@ -1,6 +1,6 @@ -- Add bmc_credential_rotation_requested column to switches table. -- bmc_credential_rotation_requested: an operator "force-converge this BMC now" --- escape hatch, the switch analogue of +-- escape hatch (REQ-2), the switch analogue of -- machines.bmc_credential_rotation_requested. When true, the switch state -- controller enters RotatingBmc and force-converges the switch BMC, bypassing -- the passive site-wide gate and the device's backoff quarantine. A switch has diff --git a/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql b/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql index 04afb6c4a4..431b25d9d0 100644 --- a/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql +++ b/crates/api-db/migrations/20260730120001_power_shelf_bmc_credential_rotation_requested.sql @@ -1,6 +1,6 @@ -- Add bmc_credential_rotation_requested column to power_shelves table. -- bmc_credential_rotation_requested: an operator "force-converge this PMC now" --- escape hatch, the power-shelf analogue of +-- escape hatch (REQ-2), the power-shelf analogue of -- machines.bmc_credential_rotation_requested and -- switches.bmc_credential_rotation_requested. When true, the power-shelf state -- controller enters RotatingBmc and force-converges the power shelf BMC (PMC), From 94bbfec24a4984ee8a341a2b559272397215fc15 Mon Sep 17 00:00:00 2001 From: Leah Itagaki Date: Tue, 11 Aug 2026 15:53:43 -0400 Subject: [PATCH 15/26] patch(v2.1): Match Core SKU behavior (#4784) (#4826) NICO Core logic to populate updated timestamps and to save and respect ethernet device information on SKUs is not yet in place, but the initial 2.1 implementation of the REST API incorrectly led users to expect updated timestamps and the ability to save ethernet device information. This corrects these errors and also ensures consistent reporting of created timestamps on SKUs. Internal issue - [ ] **Add** - New feature or capability - [ ] **Change** - Changes in existing functionality - [x] **Fix** - Bug fixes - [x] **Remove** - Removed features or deprecated functionality - [ ] **Internal** - Internal changes (refactoring, tests, docs, etc.) This could be considered a breaking change because we now return a 400 when users submit a non-empty ethernet device array, whereas before we simply dropped it without saving it, but as this fix is being made within the release where the SKU create/update endpoints were introduced, I think this is acceptable. - [x] **This PR contains breaking changes** - [x] Unit tests added/updated - [ ] Integration tests added/updated - [ ] Manual testing performed - [ ] No testing required (docs, internal refactor, etc.) --- rest-api/api/pkg/api/handler/sku.go | 14 +- rest-api/api/pkg/api/handler/sku_test.go | 88 ++++++++++++- rest-api/api/pkg/api/model/sku.go | 18 ++- rest-api/api/pkg/api/model/sku_test.go | 48 ++++++- rest-api/db/pkg/db/model/sku.go | 32 ++++- rest-api/db/pkg/db/model/sku_test.go | 46 ++++++- rest-api/docs/index.html | 122 ++++++------------ rest-api/openapi/spec.yaml | 13 +- rest-api/sdk/standard/model_sku.go | 39 +----- rest-api/sdk/standard/model_sku_components.go | 2 +- rest-api/workflow/pkg/activity/sku/sku.go | 14 +- .../workflow/pkg/activity/sku/sku_test.go | 24 +++- 12 files changed, 308 insertions(+), 152 deletions(-) diff --git a/rest-api/api/pkg/api/handler/sku.go b/rest-api/api/pkg/api/handler/sku.go index c5b441ab91..a3119c4391 100644 --- a/rest-api/api/pkg/api/handler/sku.go +++ b/rest-api/api/pkg/api/handler/sku.go @@ -9,6 +9,7 @@ import ( "fmt" "net/http" "reflect" + "time" "github.com/NVIDIA/infra-controller/rest-api/api/internal/config" "github.com/NVIDIA/infra-controller/rest-api/api/pkg/api/handler/util/common" @@ -383,6 +384,10 @@ func (csh CreateSkuHandler) Handle(c echo.Context) error { } else { projected := &cdbm.SKU{} projected.FromProto(skuToPersist, uuid.MustParse(siteID)) + var created *time.Time + if !projected.Created.IsZero() { + created = &projected.Created + } skuDAO := cdbm.NewSkuDAO(csh.dbSession) err = cdb.WithTx(ctx, csh.dbSession, func(tx *cdb.Tx) error { err := tx.TryAcquireAdvisoryLock(ctx, cdb.GetAdvisoryLockIDFromString(projected.ID), nil) @@ -393,6 +398,7 @@ func (csh CreateSkuHandler) Handle(c echo.Context) error { _, err = skuDAO.Create(ctx, tx, cdbm.SkuCreateInput{ SkuID: projected.ID, SiteID: projected.SiteID, + Created: created, Description: projected.Description, SchemaVersion: projected.SchemaVersion, Components: projected.Components, @@ -569,7 +575,8 @@ func (ush UpdateSkuHandler) Handle(c echo.Context) error { // are no associations in the authoritative projection. associatedMachineIDs = []string{} } - if existing.Description == projected.Description && + createdMatches := projected.Created.IsZero() || existing.Created.Equal(projected.Created) + if createdMatches && existing.Description == projected.Description && existing.SchemaVersion == projected.SchemaVersion && existing.Components.Equal(components) && reflect.DeepEqual(existing.DeviceType, projected.DeviceType) && @@ -577,8 +584,13 @@ func (ush UpdateSkuHandler) Handle(c echo.Context) error { return nil } + var created *time.Time + if !createdMatches { + created = &projected.Created + } _, err = skuDAO.Update(ctx, tx, cdbm.SkuUpdateInput{ SkuID: projected.ID, + Created: created, Description: &projected.Description, SchemaVersion: &projected.SchemaVersion, Components: components, diff --git a/rest-api/api/pkg/api/handler/sku_test.go b/rest-api/api/pkg/api/handler/sku_test.go index 8157e9a712..35f65b96c4 100644 --- a/rest-api/api/pkg/api/handler/sku_test.go +++ b/rest-api/api/pkg/api/handler/sku_test.go @@ -11,6 +11,7 @@ import ( "net/http/httptest" "strings" "testing" + "time" "github.com/NVIDIA/infra-controller/rest-api/api/internal/config" "github.com/NVIDIA/infra-controller/rest-api/api/pkg/api/handler/util/common" @@ -36,6 +37,7 @@ import ( "google.golang.org/grpc/status" "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/types/known/timestamppb" ) // testSkuInitDB initializes a test database session (pattern from tenant_test.go) @@ -714,6 +716,8 @@ func TestCreateSkuHandler(t *testing.T) { assert.Equal(t, req.ID, response.ID) assert.Equal(t, fixture.siteID, response.SiteID) assert.Empty(t, response.AssociatedMachineIds) + require.NotNil(t, response.Created) + assert.True(t, existingSkuCreatedTime().Equal(*response.Created)) saved, err := cdbm.NewSkuDAO(fixture.createHandler.dbSession).Get(context.Background(), nil, req.ID) require.NoError(t, err) @@ -721,6 +725,8 @@ func TestCreateSkuHandler(t *testing.T) { assert.Equal(t, response.Description, saved.Description) assert.Equal(t, response.SchemaVersion, saved.SchemaVersion) assert.Equal(t, response.DeviceType, saved.DeviceType) + assert.True(t, existingSkuCreatedTime().Round(time.Microsecond).Equal(saved.Created)) + assert.False(t, response.Created.Equal(saved.Created)) require.NotNil(t, saved.Components) require.NotNil(t, saved.Components.Chassis) // The post-create Core response is authoritative, even when it differs @@ -735,7 +741,9 @@ func TestCreateSkuHandler(t *testing.T) { }) req := validSkuCreateRequest(fixture.siteID) + beforeCreate := time.Now().UTC() rec := fixture.request(t, http.MethodPost, "", req, fixture.createHandler.Handle) + afterCreate := time.Now().UTC() require.Equal(t, http.StatusCreated, rec.Code, rec.Body.String()) require.Len(t, fixture.requests, 2) assert.Equal(t, corev1.Forge_CreateSku_FullMethodName, fixture.requests[0].FullMethod) @@ -750,7 +758,7 @@ func TestCreateSkuHandler(t *testing.T) { assert.Equal(t, req.DeviceType, response.DeviceType) assert.Equal(t, model.NewAPISkuComponents(req.Components.ToProto()), response.Components) assert.Empty(t, response.AssociatedMachineIds) - assert.Nil(t, response.Created) + assert.True(t, response.Created.After(beforeCreate)) saved, err := cdbm.NewSkuDAO(fixture.createHandler.dbSession).Get(context.Background(), nil, req.ID) require.NoError(t, err) @@ -758,6 +766,8 @@ func TestCreateSkuHandler(t *testing.T) { assert.Equal(t, *req.Description, saved.Description) assert.Equal(t, model.CoreSkuSchemaVersion, saved.SchemaVersion) assert.Equal(t, req.DeviceType, saved.DeviceType) + assert.False(t, saved.Created.Before(beforeCreate)) + assert.False(t, saved.Created.After(afterCreate)) require.NotNil(t, saved.Components) require.Len(t, saved.Components.Storage, 1) assert.Equal(t, uint32(3_600_000), saved.Components.Storage[0].GetMinSizeMb()) @@ -816,6 +826,26 @@ func TestCreateSkuHandler(t *testing.T) { assert.Empty(t, fixture.requests) }) + t.Run("rejects non-empty read-only ethernet devices", func(t *testing.T) { + fixture := newSkuManagementFixture(t, []string{authz.ProviderAdminRole}) + req := validSkuCreateRequest(fixture.siteID) + req.Components.EthernetDevices = []model.APISkuEthernetDevice{ + { + Vendor: "Mellanox Technologies", + Model: "MT2892 Family [ConnectX-6 Dx]", + Count: 2, + IsConnected: true, + }, + } + + rec := fixture.request(t, http.MethodPost, "", req, fixture.createHandler.Handle) + + require.Equal(t, http.StatusBadRequest, rec.Code, rec.Body.String()) + assert.Contains(t, rec.Body.String(), "ethernetDevices") + assert.Contains(t, rec.Body.String(), "read-only") + assert.Empty(t, fixture.requests) + }) + t.Run("rejects legacy storage mutation fields", func(t *testing.T) { fixture := newSkuManagementFixture(t, []string{authz.ProviderAdminRole}) @@ -884,17 +914,46 @@ func TestUpdateSkuHandler(t *testing.T) { require.NotNil(t, response.DeviceType) assert.Equal(t, deviceType, *response.DeviceType) assert.Equal(t, uint32(4), response.SchemaVersion) + require.NotNil(t, response.Created) + assert.True(t, existingSkuCreatedTime().Equal(*response.Created)) saved, err := cdbm.NewSkuDAO(fixture.updateHandler.dbSession).Get(context.Background(), nil, "sku-1") require.NoError(t, err) require.NotNil(t, saved.DeviceType) assert.Equal(t, deviceType, *saved.DeviceType) assert.Equal(t, uint32(4), saved.SchemaVersion) + assert.True(t, existingSkuCreatedTime().Round(time.Microsecond).Equal(saved.Created)) + assert.False(t, response.Created.Equal(saved.Created)) require.NotNil(t, saved.Components) require.NotNil(t, saved.Components.Chassis) assert.Equal(t, "existing chassis", saved.Components.Chassis.Model) }) + t.Run("preserves stored created timestamp when Core omits it", func(t *testing.T) { + existing := existingSkuProto() + existing.Created = nil + fixture := newSkuManagementFixtureWithOptions(t, []string{authz.ProviderAdminRole}, skuManagementFixtureOptions{ + findResponse: &corev1.SkuList{Skus: []*corev1.Sku{existing}}, + }) + skuDAO := cdbm.NewSkuDAO(fixture.updateHandler.dbSession) + beforeUpdate, err := skuDAO.Get(context.Background(), nil, "sku-1") + require.NoError(t, err) + description := "updated description" + + rec := fixture.request(t, http.MethodPatch, "sku-1", model.APISkuUpdateRequest{ + Description: &description, + }, fixture.updateHandler.Handle) + + require.Equal(t, http.StatusOK, rec.Code, rec.Body.String()) + var response model.APISku + require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &response)) + assert.Nil(t, response.Created) + + afterUpdate, err := skuDAO.Get(context.Background(), nil, "sku-1") + require.NoError(t, err) + assert.True(t, beforeUpdate.Created.Equal(afterUpdate.Created)) + }) + t.Run("preserves projection when Core metadataupdate fails", func(t *testing.T) { fixture := newSkuManagementFixtureWithOptions(t, []string{authz.ProviderAdminRole}, skuManagementFixtureOptions{ updateMetadataError: errors.New("Core unavailable"), @@ -1088,6 +1147,28 @@ func TestUpdateSkuHandler(t *testing.T) { assert.Empty(t, fixture.requests) }) + t.Run("rejects non-empty read-only ethernet devices", func(t *testing.T) { + fixture := newSkuManagementFixture(t, []string{authz.ProviderAdminRole}) + components := validSkuCreateRequest(fixture.siteID).Components + components.EthernetDevices = []model.APISkuEthernetDevice{ + { + Vendor: "Mellanox Technologies", + Model: "MT2892 Family [ConnectX-6 Dx]", + Count: 2, + IsConnected: true, + }, + } + + rec := fixture.request(t, http.MethodPatch, "sku-1", model.APISkuUpdateRequest{ + Components: components, + }, fixture.updateHandler.Handle) + + require.Equal(t, http.StatusBadRequest, rec.Code, rec.Body.String()) + assert.Contains(t, rec.Body.String(), "ethernetDevices") + assert.Contains(t, rec.Body.String(), "read-only") + assert.Empty(t, fixture.requests) + }) + t.Run("returns Core not found without completing update", func(t *testing.T) { fixture := newSkuManagementFixtureWithOptions(t, []string{authz.ProviderAdminRole}, skuManagementFixtureOptions{ findResponse: &corev1.SkuList{}, @@ -1388,6 +1469,7 @@ func existingSkuProto() *corev1.Sku { return &corev1.Sku{ Id: "sku-1", Description: &description, + Created: timestamppb.New(existingSkuCreatedTime()), SchemaVersion: 4, DeviceType: &deviceType, Components: &corev1.SkuComponents{ @@ -1399,3 +1481,7 @@ func existingSkuProto() *corev1.Sku { }, } } + +func existingSkuCreatedTime() time.Time { + return time.Date(2025, time.January, 2, 3, 4, 5, 678_901_234, time.UTC) +} diff --git a/rest-api/api/pkg/api/model/sku.go b/rest-api/api/pkg/api/model/sku.go index c4445fb746..4d272118ca 100644 --- a/rest-api/api/pkg/api/model/sku.go +++ b/rest-api/api/pkg/api/model/sku.go @@ -7,6 +7,7 @@ import ( "fmt" "time" + cutil "github.com/NVIDIA/infra-controller/rest-api/common/pkg/util" cdbm "github.com/NVIDIA/infra-controller/rest-api/db/pkg/db/model" corev1 "github.com/NVIDIA/infra-controller/rest-api/proto/core/gen/v1" validation "github.com/go-ozzo/ozzo-validation/v4" @@ -34,8 +35,6 @@ type APISku struct { Components *APISkuComponents `json:"components"` // Created is the date and time the entity was created Created *time.Time `json:"created"` - // Updated is the date and time the entity was last updated - Updated *time.Time `json:"updated"` } // APISkuCreateRequest is the POST /sku request body. @@ -173,6 +172,7 @@ func NewAPISkuFromCreateRequest(req APISkuCreateRequest, skuID, siteID string) * DeviceType: req.DeviceType, AssociatedMachineIds: []string{}, Components: NewAPISkuComponents(req.Components.ToProto()), + Created: cutil.GetPtr(time.Now().UTC()), // best guess in absence of data from Core } } @@ -190,7 +190,6 @@ func NewAPISku(dbSku *cdbm.SKU) *APISku { DeviceType: dbSku.DeviceType, AssociatedMachineIds: dbSku.AssociatedMachineIds, Created: &dbSku.Created, - Updated: &dbSku.Updated, } // Map SKU Components if available @@ -212,7 +211,8 @@ type APISkuComponents struct { Storage []APISkuStorage `json:"storage"` // Chassis describes chassis component Chassis *APISkuChassis `json:"chassis"` - // EthernetDevices describes ethernet device components + // EthernetDevices describes read-only ethernet device components. + // REST mutation requests may omit it or provide an empty value. EthernetDevices []APISkuEthernetDevice `json:"ethernetDevices"` // InfinibandDevices describes infiniband device components InfinibandDevices []APISkuInfinibandDevice `json:"infinibandDevices"` @@ -220,9 +220,15 @@ type APISkuComponents struct { Tpm *APISkuTpm `json:"tpm"` } -// Validate checks every storage component. +// Validate rejects unsupported component mutations and checks every storage component. func (c APISkuComponents) Validate() error { - return validation.Validate(c.Storage, validation.Each()) + return validation.ValidateStruct(&c, + validation.Field( + &c.EthernetDevices, + validation.Length(0, 0).Error("must be empty because this field is read-only"), + ), + validation.Field(&c.Storage, validation.Each()), + ) } // APISkuCpu represents a CPU component in the SKU diff --git a/rest-api/api/pkg/api/model/sku_test.go b/rest-api/api/pkg/api/model/sku_test.go index 31f6106796..98d55bf06a 100644 --- a/rest-api/api/pkg/api/model/sku_test.go +++ b/rest-api/api/pkg/api/model/sku_test.go @@ -63,7 +63,6 @@ func TestNewAPISku(t *testing.T) { DeviceType: &deviceType, AssociatedMachineIds: associatedMachineIds, Created: &createdTime, - Updated: &updatedTime, }, }, { @@ -96,7 +95,6 @@ func TestNewAPISku(t *testing.T) { assert.Equal(t, tt.want.DeviceType, got.DeviceType) assert.Equal(t, tt.want.AssociatedMachineIds, got.AssociatedMachineIds) assert.Equal(t, tt.want.Created, got.Created) - assert.Equal(t, tt.want.Updated, got.Updated) }) } } @@ -635,7 +633,6 @@ func TestNewAPISkuEdgeCases(t *testing.T) { result := NewAPISku(dbSku) assert.NotNil(t, result) assert.True(t, result.Created.IsZero()) - assert.True(t, result.Updated.IsZero()) }) } @@ -1026,8 +1023,7 @@ func TestAPISku_MarshalJSON(t *testing.T) { "infinibandDevices":null, "tpm":null }, - "created":null, - "updated":null + "created":null }`, string(encoded)) } @@ -1066,6 +1062,48 @@ func TestAPISkuStorage_Validate(t *testing.T) { } } +func TestAPISkuComponents_Validate(t *testing.T) { + for _, test := range []struct { + name string + ethernetDevices []APISkuEthernetDevice + wantErr bool + }{ + { + name: "accepts omitted ethernet devices", + }, + { + name: "accepts empty ethernet devices", + ethernetDevices: []APISkuEthernetDevice{}, + }, + { + name: "rejects non-empty ethernet devices", + ethernetDevices: []APISkuEthernetDevice{ + { + Vendor: "Mellanox Technologies", + Model: "MT2892 Family [ConnectX-6 Dx]", + Count: 2, + IsConnected: true, + }, + }, + wantErr: true, + }, + } { + t.Run(test.name, func(t *testing.T) { + components := testAPISkuComponents() + components.EthernetDevices = test.ethernetDevices + + err := components.Validate() + if test.wantErr { + require.Error(t, err) + assert.Contains(t, err.Error(), "ethernetDevices") + assert.Contains(t, err.Error(), "read-only") + return + } + assert.NoError(t, err) + }) + } +} + func TestAPISkuRequests_UnmarshalJSON(t *testing.T) { t.Run("create", func(t *testing.T) { var request APISkuCreateRequest diff --git a/rest-api/db/pkg/db/model/sku.go b/rest-api/db/pkg/db/model/sku.go index 976f363f81..2493edcbb0 100644 --- a/rest-api/db/pkg/db/model/sku.go +++ b/rest-api/db/pkg/db/model/sku.go @@ -16,6 +16,7 @@ import ( "github.com/google/uuid" "github.com/uptrace/bun" "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/types/known/timestamppb" ) const ( @@ -91,9 +92,8 @@ type SKU struct { // ToProto converts the REST database projection into its Core SKU representation. // -// The Core-level Created timestamp is omitted because the REST projection does -// not store it. SiteID is also omitted because it is not carried by the Core SKU -// message; callers supply it separately to FromProto. +// SiteID is omitted because it is not carried by the Core SKU message; callers +// supply it separately to FromProto. func (sk *SKU) ToProto() *corev1.Sku { proto := &corev1.Sku{ Id: sk.ID, @@ -101,6 +101,9 @@ func (sk *SKU) ToProto() *corev1.Sku { SchemaVersion: sk.SchemaVersion, DeviceType: sk.DeviceType, } + if !sk.Created.IsZero() { + proto.Created = timestamppb.New(sk.Created) + } if sk.Components != nil { proto.Components = sk.Components.SkuComponents } @@ -124,6 +127,9 @@ func (sk *SKU) ToProto() *corev1.Sku { // non-empty IDs at the activity layer). // - `Description` uses the protobuf default when absent, so a nil Core // description clears any stale REST projection value. +// - `Created` is normalized to REST DB precision when Core supplies a valid +// timestamp and is zero otherwise so create and update callers can apply +// their respective fallback semantics. // - `Components` mirrors the proto: stays nil when `proto.Components` // is nil, otherwise wraps it, so the activity layer can distinguish // "not provided" from "explicitly set". @@ -140,6 +146,10 @@ func (sk *SKU) FromProto(proto *corev1.Sku, siteID uuid.UUID) { sk.Description = proto.GetDescription() sk.SchemaVersion = proto.SchemaVersion sk.DeviceType = proto.DeviceType + sk.Created = time.Time{} + if proto.Created != nil && proto.Created.IsValid() { + sk.Created = proto.Created.AsTime().UTC().Round(time.Microsecond) + } if proto.Components != nil { sk.Components = &SkuComponents{SkuComponents: proto.Components} } else { @@ -167,6 +177,7 @@ type SkuCreateInput struct { Components *SkuComponents DeviceType *string AssociatedMachineIds []string + Created *time.Time } // SkuUpdateInput input parameters for Update method @@ -177,6 +188,7 @@ type SkuUpdateInput struct { Components *SkuComponents DeviceType *string AssociatedMachineIds []string + Created *time.Time } // SkuFilterInput input parameters for Filter method @@ -193,8 +205,11 @@ var _ bun.BeforeAppendModelHook = (*SKU)(nil) func (s *SKU) BeforeAppendModel(ctx context.Context, query bun.Query) error { switch query.(type) { case *bun.InsertQuery: - s.Created = db.GetCurTime() - s.Updated = db.GetCurTime() + now := db.GetCurTime() + if s.Created.IsZero() { + s.Created = now + } + s.Updated = now case *bun.UpdateQuery: s.Updated = db.GetCurTime() } @@ -248,6 +263,9 @@ func (ssd SkuSQLDAO) Create(ctx context.Context, tx *db.Tx, input SkuCreateInput Components: input.Components, AssociatedMachineIds: input.AssociatedMachineIds, } + if input.Created != nil && !input.Created.IsZero() { + sk.Created = input.Created.UTC().Round(time.Microsecond) + } _, err := db.GetIDB(tx, ssd.dbSession).NewInsert().Model(sk).Exec(ctx) if err != nil { @@ -361,6 +379,10 @@ func (ssd SkuSQLDAO) Update(ctx context.Context, tx *db.Tx, input SkuUpdateInput sk := &SKU{ID: input.SkuID} updatedFields := []string{} + if input.Created != nil && !input.Created.IsZero() { + sk.Created = input.Created.UTC().Round(time.Microsecond) + updatedFields = append(updatedFields, "created") + } if input.Description != nil { sk.Description = *input.Description diff --git a/rest-api/db/pkg/db/model/sku_test.go b/rest-api/db/pkg/db/model/sku_test.go index 6669f6a1f2..83aa6db0e6 100644 --- a/rest-api/db/pkg/db/model/sku_test.go +++ b/rest-api/db/pkg/db/model/sku_test.go @@ -6,6 +6,7 @@ package model import ( "context" "testing" + "time" cutil "github.com/NVIDIA/infra-controller/rest-api/common/pkg/util" "github.com/NVIDIA/infra-controller/rest-api/db/pkg/db" @@ -17,6 +18,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" otrace "go.opentelemetry.io/otel/trace" + "google.golang.org/protobuf/types/known/timestamppb" ) func TestSkuComponents_Equal(t *testing.T) { @@ -49,6 +51,7 @@ func TestSkuComponents_Equal(t *testing.T) { func TestSKU_ToProto(t *testing.T) { siteID := uuid.New() deviceType := "GPU" + created := time.Date(2025, time.January, 2, 3, 4, 5, 678_901_000, time.UTC) t.Run("populates proto from receiver", func(t *testing.T) { sk := &SKU{ @@ -57,6 +60,7 @@ func TestSKU_ToProto(t *testing.T) { Description: "GPU compute SKU", SchemaVersion: 5, DeviceType: &deviceType, + Created: created, Components: &SkuComponents{SkuComponents: &corev1.SkuComponents{}}, AssociatedMachineIds: []string{"m-1", "m-2"}, } @@ -66,6 +70,8 @@ func TestSKU_ToProto(t *testing.T) { assert.Equal(t, "GPU compute SKU", proto.GetDescription()) assert.Equal(t, uint32(5), proto.SchemaVersion) assert.Equal(t, &deviceType, proto.DeviceType) + require.NotNil(t, proto.Created) + assert.Equal(t, created, proto.Created.AsTime()) require.NotNil(t, proto.Components) require.Len(t, proto.AssociatedMachineIds, 2) assert.Equal(t, "m-1", proto.AssociatedMachineIds[0].Id) @@ -76,6 +82,7 @@ func TestSKU_ToProto(t *testing.T) { sk := &SKU{ID: "sku-2"} proto := sk.ToProto() require.NotNil(t, proto) + assert.Nil(t, proto.Created) assert.Nil(t, proto.Components) }) @@ -90,6 +97,8 @@ func TestSKU_ToProto(t *testing.T) { func TestSKU_FromProto(t *testing.T) { siteID := uuid.New() deviceType := "GPU" + created := time.Date(2025, time.January, 2, 3, 4, 5, 678_901_234, time.UTC) + normalizedCreated := created.Round(time.Microsecond) t.Run("nil proto leaves receiver unchanged", func(t *testing.T) { sk := &SKU{ID: "preserved", SiteID: siteID} @@ -105,6 +114,7 @@ func TestSKU_FromProto(t *testing.T) { Description: cutil.GetPtr("GPU compute SKU"), SchemaVersion: 4, DeviceType: &deviceType, + Created: timestamppb.New(created), Components: &corev1.SkuComponents{}, AssociatedMachineIds: []*corev1.MachineId{ {Id: "m-1"}, @@ -117,10 +127,26 @@ func TestSKU_FromProto(t *testing.T) { assert.Equal(t, "GPU compute SKU", sk.Description) assert.Equal(t, uint32(4), sk.SchemaVersion) assert.Equal(t, &deviceType, sk.DeviceType) + assert.Equal(t, normalizedCreated, sk.Created) assert.Equal(t, []string{"m-1", "m-2"}, sk.AssociatedMachineIds) require.NotNil(t, sk.Components) }) + t.Run("missing created timestamp clears stale value", func(t *testing.T) { + sk := &SKU{Created: created} + sk.FromProto(&corev1.Sku{Id: "sku-1"}, siteID) + assert.True(t, sk.Created.IsZero()) + }) + + t.Run("invalid created timestamp is treated as missing", func(t *testing.T) { + sk := &SKU{} + sk.FromProto(&corev1.Sku{ + Id: "sku-1", + Created: ×tamppb.Timestamp{Seconds: 253_402_300_800}, + }, siteID) + assert.True(t, sk.Created.IsZero()) + }) + t.Run("nil description clears existing description", func(t *testing.T) { sk := &SKU{Description: "stale description"} sk.FromProto(&corev1.Sku{Id: "sku-1"}, siteID) @@ -192,6 +218,8 @@ func TestSkuSQLDAO_Create(t *testing.T) { site := TestBuildSite(t, dbSession, ip, "test-site", user) ssd := NewSkuDAO(dbSession) + authoritativeCreated := time.Date(2025, time.January, 2, 3, 4, 5, 678_901_234, time.UTC) + normalizedAuthoritativeCreated := authoritativeCreated.Round(time.Microsecond) // OTEL Spanner configuration _, _, ctx = testCommonTraceProviderSetup(t, ctx) @@ -204,7 +232,7 @@ func TestSkuSQLDAO_Create(t *testing.T) { }{ { desc: "create one", - inputs: []SkuCreateInput{{SkuID: "sku-1", SiteID: site.ID, Description: "first SKU", SchemaVersion: 5, Components: &SkuComponents{SkuComponents: &corev1.SkuComponents{}}}}, + inputs: []SkuCreateInput{{SkuID: "sku-1", SiteID: site.ID, Created: &authoritativeCreated, Description: "first SKU", SchemaVersion: 5, Components: &SkuComponents{SkuComponents: &corev1.SkuComponents{}}}}, expectError: false, verifyChildSpanner: true, }, @@ -217,7 +245,9 @@ func TestSkuSQLDAO_Create(t *testing.T) { for _, tc := range tests { t.Run(tc.desc, func(t *testing.T) { for _, input := range tc.inputs { + beforeCreate := time.Now().UTC() got, err := ssd.Create(ctx, nil, input) + afterCreate := time.Now().UTC() assert.Equal(t, tc.expectError, err != nil) if !tc.expectError { assert.NotNil(t, got) @@ -227,6 +257,12 @@ func TestSkuSQLDAO_Create(t *testing.T) { if input.Components != nil { assert.NotNil(t, got.Components) } + if input.Created != nil { + assert.True(t, normalizedAuthoritativeCreated.Equal(got.Created)) + } else { + assert.False(t, got.Created.Before(beforeCreate)) + assert.False(t, got.Created.After(afterCreate)) + } } } if tc.verifyChildSpanner { @@ -349,6 +385,8 @@ func TestSkuSQLDAO_Update(t *testing.T) { created := testSkuCreateSkus(ctx, t, dbSession, site.ID) ssd := NewSkuDAO(dbSession) + authoritativeCreated := time.Date(2025, time.January, 2, 3, 4, 5, 678_901_234, time.UTC) + normalizedAuthoritativeCreated := authoritativeCreated.Round(time.Microsecond) // OTEL Spanner configuration _, _, ctx = testCommonTraceProviderSetup(t, ctx) @@ -358,17 +396,20 @@ func TestSkuSQLDAO_Update(t *testing.T) { input SkuUpdateInput expectedDescription string expectedVersion uint32 + expectedCreated time.Time }{ { desc: "update sku data", input: SkuUpdateInput{ SkuID: created[0].ID, + Created: &authoritativeCreated, Description: cutil.GetPtr("updated description"), SchemaVersion: cutil.GetPtr(uint32(5)), Components: &SkuComponents{SkuComponents: &corev1.SkuComponents{}}, }, expectedDescription: "updated description", expectedVersion: 5, + expectedCreated: normalizedAuthoritativeCreated, }, { desc: "nil description preserves stored description", @@ -379,6 +420,7 @@ func TestSkuSQLDAO_Update(t *testing.T) { }, expectedDescription: created[1].Description, expectedVersion: created[1].SchemaVersion, + expectedCreated: created[1].Created, }, { desc: "empty description clears stored description", @@ -388,6 +430,7 @@ func TestSkuSQLDAO_Update(t *testing.T) { }, expectedDescription: "", expectedVersion: created[2].SchemaVersion, + expectedCreated: created[2].Created, }, } for _, tc := range tests { @@ -398,6 +441,7 @@ func TestSkuSQLDAO_Update(t *testing.T) { assert.Equal(t, tc.input.SkuID, got.ID) assert.Equal(t, tc.expectedDescription, got.Description) assert.Equal(t, tc.expectedVersion, got.SchemaVersion) + assert.True(t, tc.expectedCreated.Equal(got.Created)) if tc.input.Components != nil { assert.NotNil(t, got.Components) } diff --git a/rest-api/docs/index.html b/rest-api/docs/index.html index 0881217b7d..4a54b03aba 100644 --- a/rest-api/docs/index.html +++ b/rest-api/docs/index.html @@ -4552,16 +4552,14 @@

Typical API Call Flow for Tenant

" class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Storage components

object (SkuChassis)

Chassis component

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array of objects (SkuInfinibandDevice)

Infiniband device components

Array of objects (SkuTpm)

TPM components

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

machineId
string or null

Optional ID of the Machine associated with this Expected Machine

object (MachineSummary)
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

List of machine IDs associated with this SKU

object (SkuComponents)

Hardware components of this SKU

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

machineId
string or null

Optional ID of the Machine associated with this Expected Machine

object (MachineSummary)
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Storage components

object (SkuChassis)

Chassis component

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array of objects (SkuInfinibandDevice)

Infiniband device components

Array of objects (SkuTpm)

TPM components

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

machineId
string or null

Optional ID of the Machine associated with this Expected Machine

object (MachineSummary)
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Storage components

object (SkuChassis)

Chassis component

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array of objects (SkuInfinibandDevice)

Infiniband device components

Array of objects (SkuTpm)

TPM components

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

machineId
string or null

Optional ID of the Machine associated with this Expected Machine

object (MachineSummary)
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

List of machine IDs associated with this SKU

object (SkuComponents)

Hardware components of this SKU

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

machineId
string or null

Optional ID of the Machine associated with this Expected Machine

object (MachineSummary)
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

List of machine IDs associated with this SKU

object (SkuComponents)

Hardware components of this SKU

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

machineId
string or null

Optional ID of the Machine associated with this Expected Machine

object (MachineSummary)
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Storage components

object (SkuChassis)

Chassis component

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array of objects (SkuInfinibandDevice)

Infiniband device components

Array of objects (SkuTpm)

TPM components

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

Response samples

Content type
application/json
[
  • {
    }
]

Create SKU

https://nico-rest-api.nico.svc.cluster.local/v2/org/{org}/nico/sku

Response samples

Content type
application/json
[
  • {
    }
]

Create SKU

Create a SKU.

The Org must have an Infrastructure Provider that owns the Site. The user must have an authorization role with the PROVIDER_ADMIN suffix.

@@ -6394,17 +6380,7 @@

Typical API Call Flow for Tenant

" class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Model of the chassis

architecture
string

Architecture of the chassis

-
Array of objects (SkuEthernetDevice)

Ethernet device components

-
Array
vendor
string

Vendor of the ethernet device

-
model
string

Model of the ethernet device

-
count
integer <uint32>

Number of ethernet devices present

-
isConnected
boolean

Whether the ethernet device is connected

-
Array of objects (SkuInfinibandDevice)
Array of objects (SkuInfinibandDevice)

Infiniband device components

Array
vendor
string

Vendor of the infiniband device

@@ -6488,8 +6464,8 @@

Typical API Call Flow for Tenant

" class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Model of the chassis

architecture
string

Architecture of the chassis

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array
vendor
string

Vendor of the ethernet device

model
string
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Vendor of the TPM

version
string

Version of the TPM

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

Request samples

Content type
application/json
{
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "id": "dgx-h100",
  • "description": "DGX H100 compute node",
  • "deviceType": "gpu-server",
  • "components": {
    }
}

Response samples

Content type
application/json
{
  • "id": "lenovo.sr650v2.cpu.1",
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "description": "Lenovo SR650 V2 compute node",
  • "schemaVersion": 5,
  • "deviceType": "gpu",
  • "associatedMachineIds": [
    ],
  • "components": {
    },
  • "created": "2019-08-24T14:15:22Z",
  • "updated": "2019-08-24T14:15:22Z"
}

Retrieve SKU

https://nico-rest-api.nico.svc.cluster.local/v2/org/{org}/nico/sku

Request samples

Content type
application/json
{
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "id": "dgx-h100",
  • "description": "DGX H100 compute node",
  • "deviceType": "gpu-server",
  • "components": {
    }
}

Response samples

Content type
application/json
{
  • "id": "lenovo.sr650v2.cpu.1",
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "description": "Lenovo SR650 V2 compute node",
  • "schemaVersion": 5,
  • "deviceType": "gpu",
  • "associatedMachineIds": [
    ],
  • "components": {
    },
  • "created": "2019-08-24T14:15:22Z"
}

Retrieve SKU

Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Model of the chassis

architecture
string

Architecture of the chassis

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array
vendor
string

Vendor of the ethernet device

model
string
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Vendor of the TPM

version
string

Version of the TPM

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

Response samples

Content type
application/json
{
  • "id": "lenovo.sr650v2.cpu.1",
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "deviceType": "gpu",
  • "associatedMachineIds": [
    ],
  • "components": {
    },
  • "created": "2019-08-24T14:15:22Z",
  • "updated": "2019-08-24T14:15:22Z"
}

Delete SKU

https://nico-rest-api.nico.svc.cluster.local/v2/org/{org}/nico/sku/{skuId}

Response samples

Content type
application/json
{
  • "id": "lenovo.sr650v2.cpu.1",
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "deviceType": "gpu",
  • "associatedMachineIds": [
    ],
  • "components": {
    },
  • "created": "2019-08-24T14:15:22Z"
}

Delete SKU

Delete an unused SKU. The Site is determined from the saved SKU record.

The Org must have an Infrastructure Provider that owns the SKU's Site. The user must have an authorization role with the PROVIDER_ADMIN suffix.

@@ -6726,17 +6698,7 @@

Typical API Call Flow for Tenant

" class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Model of the chassis

architecture
string

Architecture of the chassis

-
Array of objects (SkuEthernetDevice)

Ethernet device components

-
Array
vendor
string

Vendor of the ethernet device

-
model
string

Model of the ethernet device

-
count
integer <uint32>

Number of ethernet devices present

-
isConnected
boolean

Whether the ethernet device is connected

-
Array of objects (SkuInfinibandDevice)
Array of objects (SkuInfinibandDevice)

Infiniband device components

Array
vendor
string

Vendor of the infiniband device

@@ -6820,8 +6782,8 @@

Typical API Call Flow for Tenant

" class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Model of the chassis

architecture
string

Architecture of the chassis

-
Array of objects (SkuEthernetDevice)

Ethernet device components

+
Array of objects (SkuEthernetDevice)

Read-only Ethernet device components reported by Core. Omit this property from REST mutation requests; null and an empty array are accepted for compatibility, while a non-empty array is rejected with HTTP 400.

Array
vendor
string

Vendor of the ethernet device

model
string
Typical API Call Flow for Tenant " class="sc-iJSMbW sc-cBEgGa fiNpIH bAoMjv">

Vendor of the TPM

version
string

Version of the TPM

-
created
string <date-time>

ISO 8601 datetime when the SKU was created

-
updated
string <date-time>

ISO 8601 datetime when the SKU was last updated

+
created
string <date-time>

ISO 8601 datetime when the SKU was created, using the Site-reported timestamp when available

Request samples

Content type
application/json
{
  • "description": "DGX H100 compute node with InfiniBand",
  • "components": {
    }
}

Response samples

Content type
application/json
{
  • "id": "lenovo.sr650v2.cpu.1",
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "description": "Lenovo SR650 V2 compute node",
  • "schemaVersion": 5,
  • "deviceType": "gpu",
  • "associatedMachineIds": [
    ],
  • "components": {
    },
  • "created": "2019-08-24T14:15:22Z",
  • "updated": "2019-08-24T14:15:22Z"
}

InfiniBand Partition

https://nico-rest-api.nico.svc.cluster.local/v2/org/{org}/nico/sku/{skuId}

Request samples

Content type
application/json
{
  • "description": "DGX H100 compute node with InfiniBand",
  • "components": {
    }
}

Response samples

Content type
application/json
{
  • "id": "lenovo.sr650v2.cpu.1",
  • "siteId": "60189e9c-7d12-438c-b9ca-6998d9c364b1",
  • "description": "Lenovo SR650 V2 compute node",
  • "schemaVersion": 5,
  • "deviceType": "gpu",
  • "associatedMachineIds": [
    ],
  • "components": {
    },
  • "created": "2019-08-24T14:15:22Z"
}

InfiniBand Partition

InfiniBand (IB) is a high-performance, low-latency networking standard designed for interconnecting servers and storage in HPC (High-Performance Computing) and AI systems, utilizing RDMA (Remote Direct Memory Access) to reduce CPU overhead. InfiniBand Partitions are used to group Machines into logical partitions for network isolation and load distribution.

@@ -16928,7 +16888,7 @@

Typical API Call Flow for Tenant