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;