oxide_httpmock/

generated_httpmock.rs

// The contents of this file are generated; do not modify them.

pub mod operations {
    //! [`When`](::httpmock::When) and [`Then`](::httpmock::Then)
    //! wrappers for each operation. Each can be converted to
    //! its inner type with a call to `into_inner()`. This can
    //! be used to explicitly deviate from permitted values.
    use oxide::*;
    pub struct DeviceAuthRequestWhen(::httpmock::When);
    impl DeviceAuthRequestWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/device/auth$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::DeviceAuthRequest) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct DeviceAuthRequestThen(::httpmock::Then);
    impl DeviceAuthRequestThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct DeviceAuthConfirmWhen(::httpmock::When);
    impl DeviceAuthConfirmWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/device/confirm$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::DeviceAuthVerify) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct DeviceAuthConfirmThen(::httpmock::Then);
    impl DeviceAuthConfirmThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DeviceAccessTokenWhen(::httpmock::When);
    impl DeviceAccessTokenWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/device/token$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::DeviceAccessTokenRequest) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct DeviceAccessTokenThen(::httpmock::Then);
    impl DeviceAccessTokenThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct ProbeListWhen(::httpmock::When);
    impl ProbeListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/experimental/v1/probes$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct ProbeListThen(::httpmock::Then);
    impl ProbeListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ProbeInfoResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProbeCreateWhen(::httpmock::When);
    impl ProbeCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/experimental/v1/probes$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::ProbeCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ProbeCreateThen(::httpmock::Then);
    impl ProbeCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Probe) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProbeViewWhen(::httpmock::When);
    impl ProbeViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/experimental/v1/probes/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn probe(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/experimental/v1/probes/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }
    }

    pub struct ProbeViewThen(::httpmock::Then);
    impl ProbeViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ProbeInfo) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProbeDeleteWhen(::httpmock::When);
    impl ProbeDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/experimental/v1/probes/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn probe(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/experimental/v1/probes/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }
    }

    pub struct ProbeDeleteThen(::httpmock::Then);
    impl ProbeDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SupportBundleListWhen(::httpmock::When);
    impl SupportBundleListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/experimental/v1/system/support-bundles$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::TimeAndIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SupportBundleListThen(::httpmock::Then);
    impl SupportBundleListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SupportBundleInfoResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SupportBundleCreateWhen(::httpmock::When);
    impl SupportBundleCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/experimental/v1/system/support-bundles$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SupportBundleCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SupportBundleCreateThen(::httpmock::Then);
    impl SupportBundleCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SupportBundleInfo) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SupportBundleViewWhen(::httpmock::When);
    impl SupportBundleViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/experimental/v1/system/support-bundles/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SupportBundleViewThen(::httpmock::Then);
    impl SupportBundleViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SupportBundleInfo) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SupportBundleUpdateWhen(::httpmock::When);
    impl SupportBundleUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::PUT).path_matches(
                regex::Regex::new("^/experimental/v1/system/support-bundles/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SupportBundleUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SupportBundleUpdateThen(::httpmock::Then);
    impl SupportBundleUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SupportBundleInfo) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SupportBundleDeleteWhen(::httpmock::When);
    impl SupportBundleDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/experimental/v1/system/support-bundles/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SupportBundleDeleteThen(::httpmock::Then);
    impl SupportBundleDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SupportBundleDownloadWhen(::httpmock::When);
    impl SupportBundleDownloadWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/experimental/v1/system/support-bundles/[^/]*/download$")
                        .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}/download$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn range<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.header("range", value.to_string()))
            } else {
                Self(self.0.header_missing("range"))
            }
        }
    }

    pub struct SupportBundleDownloadThen(::httpmock::Then);
    impl SupportBundleDownloadThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct SupportBundleHeadWhen(::httpmock::When);
    impl SupportBundleHeadWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::HEAD).path_matches(
                    regex::Regex::new("^/experimental/v1/system/support-bundles/[^/]*/download$")
                        .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}/download$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn range<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.header("range", value.to_string()))
            } else {
                Self(self.0.header_missing("range"))
            }
        }
    }

    pub struct SupportBundleHeadThen(::httpmock::Then);
    impl SupportBundleHeadThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct SupportBundleDownloadFileWhen(::httpmock::When);
    impl SupportBundleDownloadFileWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new(
                        "^/experimental/v1/system/support-bundles/[^/]*/download/[^/]*$",
                    )
                    .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}/download/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn file(self, value: &str) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/.*/download/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn range<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.header("range", value.to_string()))
            } else {
                Self(self.0.header_missing("range"))
            }
        }
    }

    pub struct SupportBundleDownloadFileThen(::httpmock::Then);
    impl SupportBundleDownloadFileThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct SupportBundleHeadFileWhen(::httpmock::When);
    impl SupportBundleHeadFileWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::HEAD).path_matches(
                    regex::Regex::new(
                        "^/experimental/v1/system/support-bundles/[^/]*/download/[^/]*$",
                    )
                    .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}/download/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn file(self, value: &str) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/.*/download/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn range<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.header("range", value.to_string()))
            } else {
                Self(self.0.header_missing("range"))
            }
        }
    }

    pub struct SupportBundleHeadFileThen(::httpmock::Then);
    impl SupportBundleHeadFileThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct SupportBundleIndexWhen(::httpmock::When);
    impl SupportBundleIndexWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/experimental/v1/system/support-bundles/[^/]*/index$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn bundle_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/experimental/v1/system/support-bundles/{}/index$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn range<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.header("range", value.to_string()))
            } else {
                Self(self.0.header_missing("range"))
            }
        }
    }

    pub struct SupportBundleIndexThen(::httpmock::Then);
    impl SupportBundleIndexThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16, value: ::serde_json::Value) -> Self {
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct LoginSamlWhen(::httpmock::When);
    impl LoginSamlWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/login/[^/]*/saml/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo_name(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!("^/login/{}/saml/.*$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn provider_name(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!("^/login/.*/saml/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: ::serde_json::Value) -> Self {
            Self(self.0.json_body(value))
        }
    }

    pub struct LoginSamlThen(::httpmock::Then);
    impl LoginSamlThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn see_other(self) -> Self {
            Self(self.0.status(303u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn success(self, status: u16, value: ::serde_json::Value) -> Self {
            assert_eq!(status / 100u16, 2u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body(value),
            )
        }
    }

    pub struct AffinityGroupListWhen(::httpmock::When);
    impl AffinityGroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/affinity-groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct AffinityGroupListThen(::httpmock::Then);
    impl AffinityGroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AffinityGroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupCreateWhen(::httpmock::When);
    impl AffinityGroupCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/affinity-groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::AffinityGroupCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct AffinityGroupCreateThen(::httpmock::Then);
    impl AffinityGroupCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AffinityGroup) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupViewWhen(::httpmock::When);
    impl AffinityGroupViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/affinity-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/affinity-groups/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AffinityGroupViewThen(::httpmock::Then);
    impl AffinityGroupViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AffinityGroup) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupUpdateWhen(::httpmock::When);
    impl AffinityGroupUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/affinity-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/affinity-groups/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::AffinityGroupUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct AffinityGroupUpdateThen(::httpmock::Then);
    impl AffinityGroupUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AffinityGroup) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupDeleteWhen(::httpmock::When);
    impl AffinityGroupDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/affinity-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/affinity-groups/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AffinityGroupDeleteThen(::httpmock::Then);
    impl AffinityGroupDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupMemberListWhen(::httpmock::When);
    impl AffinityGroupMemberListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/affinity-groups/[^/]*/members$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/{}/members$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct AffinityGroupMemberListThen(::httpmock::Then);
    impl AffinityGroupMemberListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AffinityGroupMemberResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupMemberInstanceViewWhen(::httpmock::When);
    impl AffinityGroupMemberInstanceViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/affinity-groups/[^/]*/members/instance/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/{}/members/instance/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/.*/members/instance/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AffinityGroupMemberInstanceViewThen(::httpmock::Then);
    impl AffinityGroupMemberInstanceViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AffinityGroupMember) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupMemberInstanceAddWhen(::httpmock::When);
    impl AffinityGroupMemberInstanceAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/affinity-groups/[^/]*/members/instance/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/{}/members/instance/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/.*/members/instance/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AffinityGroupMemberInstanceAddThen(::httpmock::Then);
    impl AffinityGroupMemberInstanceAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AffinityGroupMember) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AffinityGroupMemberInstanceDeleteWhen(::httpmock::When);
    impl AffinityGroupMemberInstanceDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/affinity-groups/[^/]*/members/instance/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/{}/members/instance/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/affinity-groups/.*/members/instance/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AffinityGroupMemberInstanceDeleteThen(::httpmock::Then);
    impl AffinityGroupMemberInstanceDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertClassListWhen(::httpmock::When);
    impl AlertClassListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/alert-classes$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn filter<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::AlertSubscription>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("filter", value.to_string()))
            } else {
                Self(self.0.query_param_missing("filter"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }
    }

    pub struct AlertClassListThen(::httpmock::Then);
    impl AlertClassListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AlertClassResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertReceiverListWhen(::httpmock::When);
    impl AlertReceiverListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/alert-receivers$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct AlertReceiverListThen(::httpmock::Then);
    impl AlertReceiverListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AlertReceiverResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertReceiverViewWhen(::httpmock::When);
    impl AlertReceiverViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/alert-receivers/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/alert-receivers/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct AlertReceiverViewThen(::httpmock::Then);
    impl AlertReceiverViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AlertReceiver) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertReceiverDeleteWhen(::httpmock::When);
    impl AlertReceiverDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/alert-receivers/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/alert-receivers/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct AlertReceiverDeleteThen(::httpmock::Then);
    impl AlertReceiverDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertDeliveryListWhen(::httpmock::When);
    impl AlertDeliveryListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/alert-receivers/[^/]*/deliveries$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/alert-receivers/{}/deliveries$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn delivered<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("delivered", value.to_string()))
            } else {
                Self(self.0.query_param_missing("delivered"))
            }
        }

        pub fn failed<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("failed", value.to_string()))
            } else {
                Self(self.0.query_param_missing("failed"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn pending<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("pending", value.to_string()))
            } else {
                Self(self.0.query_param_missing("pending"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::TimeAndIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct AlertDeliveryListThen(::httpmock::Then);
    impl AlertDeliveryListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AlertDeliveryResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertReceiverProbeWhen(::httpmock::When);
    impl AlertReceiverProbeWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/alert-receivers/[^/]*/probe$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/alert-receivers/{}/probe$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn resend<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("resend", value.to_string()))
            } else {
                Self(self.0.query_param_missing("resend"))
            }
        }
    }

    pub struct AlertReceiverProbeThen(::httpmock::Then);
    impl AlertReceiverProbeThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AlertProbeResult) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertReceiverSubscriptionAddWhen(::httpmock::When);
    impl AlertReceiverSubscriptionAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/alert-receivers/[^/]*/subscriptions$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/alert-receivers/{}/subscriptions$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::AlertSubscriptionCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct AlertReceiverSubscriptionAddThen(::httpmock::Then);
    impl AlertReceiverSubscriptionAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AlertSubscriptionCreated) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertReceiverSubscriptionRemoveWhen(::httpmock::When);
    impl AlertReceiverSubscriptionRemoveWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/alert-receivers/[^/]*/subscriptions/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/alert-receivers/{}/subscriptions/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn subscription(self, value: &types::AlertSubscription) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/alert-receivers/.*/subscriptions/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct AlertReceiverSubscriptionRemoveThen(::httpmock::Then);
    impl AlertReceiverSubscriptionRemoveThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AlertDeliveryResendWhen(::httpmock::When);
    impl AlertDeliveryResendWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/alerts/[^/]*/resend$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn alert_id(self, value: &::uuid::Uuid) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/alerts/{}/resend$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("receiver", value.to_string()))
        }
    }

    pub struct AlertDeliveryResendThen(::httpmock::Then);
    impl AlertDeliveryResendThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AlertDeliveryId) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupListWhen(::httpmock::When);
    impl AntiAffinityGroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/anti-affinity-groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct AntiAffinityGroupListThen(::httpmock::Then);
    impl AntiAffinityGroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AntiAffinityGroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupCreateWhen(::httpmock::When);
    impl AntiAffinityGroupCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/anti-affinity-groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::AntiAffinityGroupCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct AntiAffinityGroupCreateThen(::httpmock::Then);
    impl AntiAffinityGroupCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AntiAffinityGroup) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupViewWhen(::httpmock::When);
    impl AntiAffinityGroupViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/anti-affinity-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/anti-affinity-groups/{}$", value.to_string()))
                    .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AntiAffinityGroupViewThen(::httpmock::Then);
    impl AntiAffinityGroupViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AntiAffinityGroup) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupUpdateWhen(::httpmock::When);
    impl AntiAffinityGroupUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/anti-affinity-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/anti-affinity-groups/{}$", value.to_string()))
                    .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::AntiAffinityGroupUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct AntiAffinityGroupUpdateThen(::httpmock::Then);
    impl AntiAffinityGroupUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AntiAffinityGroup) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupDeleteWhen(::httpmock::When);
    impl AntiAffinityGroupDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/anti-affinity-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/anti-affinity-groups/{}$", value.to_string()))
                    .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AntiAffinityGroupDeleteThen(::httpmock::Then);
    impl AntiAffinityGroupDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupMemberListWhen(::httpmock::When);
    impl AntiAffinityGroupMemberListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/anti-affinity-groups/[^/]*/members$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/{}/members$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct AntiAffinityGroupMemberListThen(::httpmock::Then);
    impl AntiAffinityGroupMemberListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AntiAffinityGroupMemberResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupMemberInstanceViewWhen(::httpmock::When);
    impl AntiAffinityGroupMemberInstanceViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/anti-affinity-groups/[^/]*/members/instance/[^/]*$")
                        .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/{}/members/instance/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/.*/members/instance/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AntiAffinityGroupMemberInstanceViewThen(::httpmock::Then);
    impl AntiAffinityGroupMemberInstanceViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AntiAffinityGroupMember) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupMemberInstanceAddWhen(::httpmock::When);
    impl AntiAffinityGroupMemberInstanceAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/anti-affinity-groups/[^/]*/members/instance/[^/]*$")
                        .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/{}/members/instance/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/.*/members/instance/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AntiAffinityGroupMemberInstanceAddThen(::httpmock::Then);
    impl AntiAffinityGroupMemberInstanceAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AntiAffinityGroupMember) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AntiAffinityGroupMemberInstanceDeleteWhen(::httpmock::When);
    impl AntiAffinityGroupMemberInstanceDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::DELETE).path_matches(
                    regex::Regex::new("^/v1/anti-affinity-groups/[^/]*/members/instance/[^/]*$")
                        .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn anti_affinity_group(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/{}/members/instance/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/anti-affinity-groups/.*/members/instance/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct AntiAffinityGroupMemberInstanceDeleteThen(::httpmock::Then);
    impl AntiAffinityGroupMemberInstanceDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AuthSettingsViewWhen(::httpmock::When);
    impl AuthSettingsViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/auth-settings$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct AuthSettingsViewThen(::httpmock::Then);
    impl AuthSettingsViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloAuthSettings) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AuthSettingsUpdateWhen(::httpmock::When);
    impl AuthSettingsUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/auth-settings$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SiloAuthSettingsUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct AuthSettingsUpdateThen(::httpmock::Then);
    impl AuthSettingsUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloAuthSettings) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CertificateListWhen(::httpmock::When);
    impl CertificateListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/certificates$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct CertificateListThen(::httpmock::Then);
    impl CertificateListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::CertificateResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CertificateCreateWhen(::httpmock::When);
    impl CertificateCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/certificates$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::CertificateCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct CertificateCreateThen(::httpmock::Then);
    impl CertificateCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Certificate) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CertificateViewWhen(::httpmock::When);
    impl CertificateViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/certificates/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn certificate(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/certificates/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct CertificateViewThen(::httpmock::Then);
    impl CertificateViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Certificate) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CertificateDeleteWhen(::httpmock::When);
    impl CertificateDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/certificates/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn certificate(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/certificates/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct CertificateDeleteThen(::httpmock::Then);
    impl CertificateDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskListWhen(::httpmock::When);
    impl DiskListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/disks$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct DiskListThen(::httpmock::Then);
    impl DiskListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::DiskResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskCreateWhen(::httpmock::When);
    impl DiskCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/disks$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::DiskCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct DiskCreateThen(::httpmock::Then);
    impl DiskCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Disk) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskViewWhen(::httpmock::When);
    impl DiskViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/disks/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/disks/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct DiskViewThen(::httpmock::Then);
    impl DiskViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Disk) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskDeleteWhen(::httpmock::When);
    impl DiskDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/disks/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/disks/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct DiskDeleteThen(::httpmock::Then);
    impl DiskDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskBulkWriteImportWhen(::httpmock::When);
    impl DiskBulkWriteImportWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/disks/[^/]*/bulk-write$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/disks/{}/bulk-write$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::ImportBlocksBulkWrite) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct DiskBulkWriteImportThen(::httpmock::Then);
    impl DiskBulkWriteImportThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskBulkWriteImportStartWhen(::httpmock::When);
    impl DiskBulkWriteImportStartWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/disks/[^/]*/bulk-write-start$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/disks/{}/bulk-write-start$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct DiskBulkWriteImportStartThen(::httpmock::Then);
    impl DiskBulkWriteImportStartThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskBulkWriteImportStopWhen(::httpmock::When);
    impl DiskBulkWriteImportStopWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/disks/[^/]*/bulk-write-stop$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/disks/{}/bulk-write-stop$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct DiskBulkWriteImportStopThen(::httpmock::Then);
    impl DiskBulkWriteImportStopThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct DiskFinalizeImportWhen(::httpmock::When);
    impl DiskFinalizeImportWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/disks/[^/]*/finalize$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/disks/{}/finalize$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::FinalizeDisk) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct DiskFinalizeImportThen(::httpmock::Then);
    impl DiskFinalizeImportThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetListWhen(::httpmock::When);
    impl ExternalSubnetListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/external-subnets$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct ExternalSubnetListThen(::httpmock::Then);
    impl ExternalSubnetListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ExternalSubnetResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetCreateWhen(::httpmock::When);
    impl ExternalSubnetCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/external-subnets$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::ExternalSubnetCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ExternalSubnetCreateThen(::httpmock::Then);
    impl ExternalSubnetCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::ExternalSubnet) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetViewWhen(::httpmock::When);
    impl ExternalSubnetViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/external-subnets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn external_subnet(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/external-subnets/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct ExternalSubnetViewThen(::httpmock::Then);
    impl ExternalSubnetViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ExternalSubnet) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetUpdateWhen(::httpmock::When);
    impl ExternalSubnetUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/external-subnets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn external_subnet(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/external-subnets/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::ExternalSubnetUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ExternalSubnetUpdateThen(::httpmock::Then);
    impl ExternalSubnetUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ExternalSubnet) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetDeleteWhen(::httpmock::When);
    impl ExternalSubnetDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/external-subnets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn external_subnet(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/external-subnets/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct ExternalSubnetDeleteThen(::httpmock::Then);
    impl ExternalSubnetDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetAttachWhen(::httpmock::When);
    impl ExternalSubnetAttachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/external-subnets/[^/]*/attach$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn external_subnet(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/external-subnets/{}/attach$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::ExternalSubnetAttach) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ExternalSubnetAttachThen(::httpmock::Then);
    impl ExternalSubnetAttachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::ExternalSubnet) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ExternalSubnetDetachWhen(::httpmock::When);
    impl ExternalSubnetDetachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/external-subnets/[^/]*/detach$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn external_subnet(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/external-subnets/{}/detach$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct ExternalSubnetDetachThen(::httpmock::Then);
    impl ExternalSubnetDetachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::ExternalSubnet) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpListWhen(::httpmock::When);
    impl FloatingIpListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/floating-ips$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct FloatingIpListThen(::httpmock::Then);
    impl FloatingIpListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::FloatingIpResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpCreateWhen(::httpmock::When);
    impl FloatingIpCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/floating-ips$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::FloatingIpCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct FloatingIpCreateThen(::httpmock::Then);
    impl FloatingIpCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::FloatingIp) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpViewWhen(::httpmock::When);
    impl FloatingIpViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/floating-ips/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn floating_ip(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/floating-ips/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct FloatingIpViewThen(::httpmock::Then);
    impl FloatingIpViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::FloatingIp) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpUpdateWhen(::httpmock::When);
    impl FloatingIpUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/floating-ips/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn floating_ip(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/floating-ips/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::FloatingIpUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct FloatingIpUpdateThen(::httpmock::Then);
    impl FloatingIpUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::FloatingIp) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpDeleteWhen(::httpmock::When);
    impl FloatingIpDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/floating-ips/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn floating_ip(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/floating-ips/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct FloatingIpDeleteThen(::httpmock::Then);
    impl FloatingIpDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpAttachWhen(::httpmock::When);
    impl FloatingIpAttachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/floating-ips/[^/]*/attach$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn floating_ip(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/floating-ips/{}/attach$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::FloatingIpAttach) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct FloatingIpAttachThen(::httpmock::Then);
    impl FloatingIpAttachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::FloatingIp) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct FloatingIpDetachWhen(::httpmock::When);
    impl FloatingIpDetachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/floating-ips/[^/]*/detach$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn floating_ip(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/floating-ips/{}/detach$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct FloatingIpDetachThen(::httpmock::Then);
    impl FloatingIpDetachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::FloatingIp) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct GroupListWhen(::httpmock::When);
    impl GroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct GroupListThen(::httpmock::Then);
    impl GroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::GroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct GroupViewWhen(::httpmock::When);
    impl GroupViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn group_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!("^/v1/groups/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct GroupViewThen(::httpmock::Then);
    impl GroupViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Group) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ImageListWhen(::httpmock::When);
    impl ImageListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/images$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct ImageListThen(::httpmock::Then);
    impl ImageListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ImageResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ImageCreateWhen(::httpmock::When);
    impl ImageCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/images$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::ImageCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ImageCreateThen(::httpmock::Then);
    impl ImageCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Image) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ImageViewWhen(::httpmock::When);
    impl ImageViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/images/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn image(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/images/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct ImageViewThen(::httpmock::Then);
    impl ImageViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Image) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ImageDeleteWhen(::httpmock::When);
    impl ImageDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/images/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn image(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/images/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct ImageDeleteThen(::httpmock::Then);
    impl ImageDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ImageDemoteWhen(::httpmock::When);
    impl ImageDemoteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/images/[^/]*/demote$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn image(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/images/{}/demote$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }
    }

    pub struct ImageDemoteThen(::httpmock::Then);
    impl ImageDemoteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Image) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ImagePromoteWhen(::httpmock::When);
    impl ImagePromoteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/images/[^/]*/promote$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn image(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/images/{}/promote$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct ImagePromoteThen(::httpmock::Then);
    impl ImagePromoteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Image) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceListWhen(::httpmock::When);
    impl InstanceListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/instances$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceListThen(::httpmock::Then);
    impl InstanceListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InstanceResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceCreateWhen(::httpmock::When);
    impl InstanceCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/instances$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::InstanceCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceCreateThen(::httpmock::Then);
    impl InstanceCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Instance) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceViewWhen(::httpmock::When);
    impl InstanceViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/instances/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceViewThen(::httpmock::Then);
    impl InstanceViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Instance) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceUpdateWhen(::httpmock::When);
    impl InstanceUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/instances/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::InstanceUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceUpdateThen(::httpmock::Then);
    impl InstanceUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Instance) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceDeleteWhen(::httpmock::When);
    impl InstanceDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/instances/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceDeleteThen(::httpmock::Then);
    impl InstanceDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceAffinityGroupListWhen(::httpmock::When);
    impl InstanceAffinityGroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/instances/[^/]*/affinity-groups$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/affinity-groups$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceAffinityGroupListThen(::httpmock::Then);
    impl InstanceAffinityGroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AffinityGroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceAntiAffinityGroupListWhen(::httpmock::When);
    impl InstanceAntiAffinityGroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/instances/[^/]*/anti-affinity-groups$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/anti-affinity-groups$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceAntiAffinityGroupListThen(::httpmock::Then);
    impl InstanceAntiAffinityGroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AntiAffinityGroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceDiskListWhen(::httpmock::When);
    impl InstanceDiskListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/disks$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/instances/{}/disks$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceDiskListThen(::httpmock::Then);
    impl InstanceDiskListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::DiskResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceDiskAttachWhen(::httpmock::When);
    impl InstanceDiskAttachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/disks/attach$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/disks/attach$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::DiskPath) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceDiskAttachThen(::httpmock::Then);
    impl InstanceDiskAttachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Disk) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceDiskDetachWhen(::httpmock::When);
    impl InstanceDiskDetachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/disks/detach$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/disks/detach$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::DiskPath) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceDiskDetachThen(::httpmock::Then);
    impl InstanceDiskDetachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Disk) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceExternalIpListWhen(::httpmock::When);
    impl InstanceExternalIpListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/external-ips$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/external-ips$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceExternalIpListThen(::httpmock::Then);
    impl InstanceExternalIpListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ExternalIpResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceEphemeralIpAttachWhen(::httpmock::When);
    impl InstanceEphemeralIpAttachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/instances/[^/]*/external-ips/ephemeral$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/external-ips/ephemeral$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::EphemeralIpCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceEphemeralIpAttachThen(::httpmock::Then);
    impl InstanceEphemeralIpAttachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::ExternalIp) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceEphemeralIpDetachWhen(::httpmock::When);
    impl InstanceEphemeralIpDetachWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/instances/[^/]*/external-ips/ephemeral$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/external-ips/ephemeral$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn ip_version<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IpVersion>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("ip_version", value.to_string()))
            } else {
                Self(self.0.query_param_missing("ip_version"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceEphemeralIpDetachThen(::httpmock::Then);
    impl InstanceEphemeralIpDetachThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceExternalSubnetListWhen(::httpmock::When);
    impl InstanceExternalSubnetListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/instances/[^/]*/external-subnets$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/external-subnets$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceExternalSubnetListThen(::httpmock::Then);
    impl InstanceExternalSubnetListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ExternalSubnetResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceMulticastGroupListWhen(::httpmock::When);
    impl InstanceMulticastGroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/instances/[^/]*/multicast-groups$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/multicast-groups$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceMulticastGroupListThen(::httpmock::Then);
    impl InstanceMulticastGroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::MulticastGroupMemberResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceMulticastGroupJoinWhen(::httpmock::When);
    impl InstanceMulticastGroupJoinWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::PUT).path_matches(
                regex::Regex::new("^/v1/instances/[^/]*/multicast-groups/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/multicast-groups/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn multicast_group(self, value: &types::MulticastGroupIdentifier) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/.*/multicast-groups/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::InstanceMulticastGroupJoin) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceMulticastGroupJoinThen(::httpmock::Then);
    impl InstanceMulticastGroupJoinThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::MulticastGroupMember) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceMulticastGroupLeaveWhen(::httpmock::When);
    impl InstanceMulticastGroupLeaveWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/instances/[^/]*/multicast-groups/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/multicast-groups/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn multicast_group(self, value: &types::MulticastGroupIdentifier) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/.*/multicast-groups/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceMulticastGroupLeaveThen(::httpmock::Then);
    impl InstanceMulticastGroupLeaveThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceRebootWhen(::httpmock::When);
    impl InstanceRebootWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/reboot$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/instances/{}/reboot$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceRebootThen(::httpmock::Then);
    impl InstanceRebootThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Instance) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceSerialConsoleWhen(::httpmock::When);
    impl InstanceSerialConsoleWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/instances/[^/]*/serial-console$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/serial-console$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn from_start<T>(self, value: T) -> Self
        where
            T: Into<Option<u64>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("from_start", value.to_string()))
            } else {
                Self(self.0.query_param_missing("from_start"))
            }
        }

        pub fn max_bytes<T>(self, value: T) -> Self
        where
            T: Into<Option<u64>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("max_bytes", value.to_string()))
            } else {
                Self(self.0.query_param_missing("max_bytes"))
            }
        }

        pub fn most_recent<T>(self, value: T) -> Self
        where
            T: Into<Option<u64>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("most_recent", value.to_string()))
            } else {
                Self(self.0.query_param_missing("most_recent"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceSerialConsoleThen(::httpmock::Then);
    impl InstanceSerialConsoleThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InstanceSerialConsoleData) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceSerialConsoleStreamWhen(::httpmock::When);
    impl InstanceSerialConsoleStreamWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/instances/[^/]*/serial-console/stream$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/serial-console/stream$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn most_recent<T>(self, value: T) -> Self
        where
            T: Into<Option<u64>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("most_recent", value.to_string()))
            } else {
                Self(self.0.query_param_missing("most_recent"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceSerialConsoleStreamThen(::httpmock::Then);
    impl InstanceSerialConsoleStreamThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn default_response(self, status: u16) -> Self {
            Self(self.0.status(status))
        }

        pub fn switching_protocols(self) -> Self {
            Self(self.0.status(101u16))
        }
    }

    pub struct InstanceSshPublicKeyListWhen(::httpmock::When);
    impl InstanceSshPublicKeyListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/instances/[^/]*/ssh-public-keys$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/instances/{}/ssh-public-keys$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceSshPublicKeyListThen(::httpmock::Then);
    impl InstanceSshPublicKeyListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SshKeyResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceStartWhen(::httpmock::When);
    impl InstanceStartWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/start$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/instances/{}/start$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceStartThen(::httpmock::Then);
    impl InstanceStartThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Instance) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceStopWhen(::httpmock::When);
    impl InstanceStopWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/instances/[^/]*/stop$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/instances/{}/stop$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceStopThen(::httpmock::Then);
    impl InstanceStopThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn accepted(self, value: &types::Instance) -> Self {
            Self(
                self.0
                    .status(202u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayIpAddressListWhen(::httpmock::When);
    impl InternetGatewayIpAddressListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/internet-gateway-ip-addresses$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn gateway<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("gateway", value.to_string()))
            } else {
                Self(self.0.query_param_missing("gateway"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayIpAddressListThen(::httpmock::Then);
    impl InternetGatewayIpAddressListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InternetGatewayIpAddressResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayIpAddressCreateWhen(::httpmock::When);
    impl InternetGatewayIpAddressCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/internet-gateway-ip-addresses$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn gateway(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("gateway", value.to_string()))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }

        pub fn body(self, value: &types::InternetGatewayIpAddressCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InternetGatewayIpAddressCreateThen(::httpmock::Then);
    impl InternetGatewayIpAddressCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::InternetGatewayIpAddress) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayIpAddressDeleteWhen(::httpmock::When);
    impl InternetGatewayIpAddressDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/internet-gateway-ip-addresses/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn address(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/internet-gateway-ip-addresses/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn cascade<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("cascade", value.to_string()))
            } else {
                Self(self.0.query_param_missing("cascade"))
            }
        }

        pub fn gateway<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("gateway", value.to_string()))
            } else {
                Self(self.0.query_param_missing("gateway"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayIpAddressDeleteThen(::httpmock::Then);
    impl InternetGatewayIpAddressDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayIpPoolListWhen(::httpmock::When);
    impl InternetGatewayIpPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/internet-gateway-ip-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn gateway<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("gateway", value.to_string()))
            } else {
                Self(self.0.query_param_missing("gateway"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayIpPoolListThen(::httpmock::Then);
    impl InternetGatewayIpPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InternetGatewayIpPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayIpPoolCreateWhen(::httpmock::When);
    impl InternetGatewayIpPoolCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/internet-gateway-ip-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn gateway(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("gateway", value.to_string()))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }

        pub fn body(self, value: &types::InternetGatewayIpPoolCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InternetGatewayIpPoolCreateThen(::httpmock::Then);
    impl InternetGatewayIpPoolCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::InternetGatewayIpPool) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayIpPoolDeleteWhen(::httpmock::When);
    impl InternetGatewayIpPoolDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::DELETE).path_matches(
                    regex::Regex::new("^/v1/internet-gateway-ip-pools/[^/]*$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/internet-gateway-ip-pools/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn cascade<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("cascade", value.to_string()))
            } else {
                Self(self.0.query_param_missing("cascade"))
            }
        }

        pub fn gateway<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("gateway", value.to_string()))
            } else {
                Self(self.0.query_param_missing("gateway"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayIpPoolDeleteThen(::httpmock::Then);
    impl InternetGatewayIpPoolDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayListWhen(::httpmock::When);
    impl InternetGatewayListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/internet-gateways$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayListThen(::httpmock::Then);
    impl InternetGatewayListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InternetGatewayResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayCreateWhen(::httpmock::When);
    impl InternetGatewayCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/internet-gateways$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("vpc", value.to_string()))
        }

        pub fn body(self, value: &types::InternetGatewayCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InternetGatewayCreateThen(::httpmock::Then);
    impl InternetGatewayCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::InternetGateway) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayViewWhen(::httpmock::When);
    impl InternetGatewayViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/internet-gateways/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn gateway(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/internet-gateways/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayViewThen(::httpmock::Then);
    impl InternetGatewayViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InternetGateway) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InternetGatewayDeleteWhen(::httpmock::When);
    impl InternetGatewayDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/internet-gateways/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn gateway(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/internet-gateways/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn cascade<T>(self, value: T) -> Self
        where
            T: Into<Option<bool>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("cascade", value.to_string()))
            } else {
                Self(self.0.query_param_missing("cascade"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct InternetGatewayDeleteThen(::httpmock::Then);
    impl InternetGatewayDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct IpPoolListWhen(::httpmock::When);
    impl IpPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/ip-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct IpPoolListThen(::httpmock::Then);
    impl IpPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloIpPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct IpPoolViewWhen(::httpmock::When);
    impl IpPoolViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/ip-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/ip-pools/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct IpPoolViewThen(::httpmock::Then);
    impl IpPoolViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloIpPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct LoginLocalWhen(::httpmock::When);
    impl LoginLocalWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/login/[^/]*/local$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo_name(self, value: &types::Name) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/login/{}/local$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::UsernamePasswordCredentials) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct LoginLocalThen(::httpmock::Then);
    impl LoginLocalThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct LogoutWhen(::httpmock::When);
    impl LogoutWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/logout$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct LogoutThen(::httpmock::Then);
    impl LogoutThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserViewWhen(::httpmock::When);
    impl CurrentUserViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/me$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct CurrentUserViewThen(::httpmock::Then);
    impl CurrentUserViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::CurrentUser) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserAccessTokenListWhen(::httpmock::When);
    impl CurrentUserAccessTokenListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/me/access-tokens$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct CurrentUserAccessTokenListThen(::httpmock::Then);
    impl CurrentUserAccessTokenListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::DeviceAccessTokenResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserAccessTokenDeleteWhen(::httpmock::When);
    impl CurrentUserAccessTokenDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/me/access-tokens/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn token_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!("^/v1/me/access-tokens/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct CurrentUserAccessTokenDeleteThen(::httpmock::Then);
    impl CurrentUserAccessTokenDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserGroupsWhen(::httpmock::When);
    impl CurrentUserGroupsWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/me/groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct CurrentUserGroupsThen(::httpmock::Then);
    impl CurrentUserGroupsThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::GroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserSshKeyListWhen(::httpmock::When);
    impl CurrentUserSshKeyListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/me/ssh-keys$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct CurrentUserSshKeyListThen(::httpmock::Then);
    impl CurrentUserSshKeyListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SshKeyResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserSshKeyCreateWhen(::httpmock::When);
    impl CurrentUserSshKeyCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/me/ssh-keys$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SshKeyCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct CurrentUserSshKeyCreateThen(::httpmock::Then);
    impl CurrentUserSshKeyCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SshKey) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserSshKeyViewWhen(::httpmock::When);
    impl CurrentUserSshKeyViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/me/ssh-keys/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn ssh_key(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/me/ssh-keys/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct CurrentUserSshKeyViewThen(::httpmock::Then);
    impl CurrentUserSshKeyViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SshKey) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct CurrentUserSshKeyDeleteWhen(::httpmock::When);
    impl CurrentUserSshKeyDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/me/ssh-keys/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn ssh_key(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/me/ssh-keys/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct CurrentUserSshKeyDeleteThen(::httpmock::Then);
    impl CurrentUserSshKeyDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloMetricWhen(::httpmock::When);
    impl SiloMetricWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/metrics/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn metric_name(self, value: types::SystemMetricName) -> Self {
            let re = regex::Regex::new(&format!("^/v1/metrics/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn end_time<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("end_time", value.to_string()))
            } else {
                Self(self.0.query_param_missing("end_time"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn order<T>(self, value: T) -> Self
        where
            T: Into<Option<types::PaginationOrder>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("order", value.to_string()))
            } else {
                Self(self.0.query_param_missing("order"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn start_time<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("start_time", value.to_string()))
            } else {
                Self(self.0.query_param_missing("start_time"))
            }
        }
    }

    pub struct SiloMetricThen(::httpmock::Then);
    impl SiloMetricThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::MeasurementResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct MulticastGroupListWhen(::httpmock::When);
    impl MulticastGroupListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/multicast-groups$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct MulticastGroupListThen(::httpmock::Then);
    impl MulticastGroupListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::MulticastGroupResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct MulticastGroupViewWhen(::httpmock::When);
    impl MulticastGroupViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/multicast-groups/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn multicast_group(self, value: &types::MulticastGroupIdentifier) -> Self {
            let re = regex::Regex::new(&format!("^/v1/multicast-groups/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct MulticastGroupViewThen(::httpmock::Then);
    impl MulticastGroupViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::MulticastGroup) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct MulticastGroupMemberListWhen(::httpmock::When);
    impl MulticastGroupMemberListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/multicast-groups/[^/]*/members$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn multicast_group(self, value: &types::MulticastGroupIdentifier) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/multicast-groups/{}/members$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct MulticastGroupMemberListThen(::httpmock::Then);
    impl MulticastGroupMemberListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::MulticastGroupMemberResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceNetworkInterfaceListWhen(::httpmock::When);
    impl InstanceNetworkInterfaceListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/network-interfaces$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("instance", value.to_string()))
            } else {
                Self(self.0.query_param_missing("instance"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct InstanceNetworkInterfaceListThen(::httpmock::Then);
    impl InstanceNetworkInterfaceListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InstanceNetworkInterfaceResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceNetworkInterfaceCreateWhen(::httpmock::When);
    impl InstanceNetworkInterfaceCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/network-interfaces$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn instance(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("instance", value.to_string()))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::InstanceNetworkInterfaceCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceNetworkInterfaceCreateThen(::httpmock::Then);
    impl InstanceNetworkInterfaceCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::InstanceNetworkInterface) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceNetworkInterfaceViewWhen(::httpmock::When);
    impl InstanceNetworkInterfaceViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/network-interfaces/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn interface(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/network-interfaces/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("instance", value.to_string()))
            } else {
                Self(self.0.query_param_missing("instance"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceNetworkInterfaceViewThen(::httpmock::Then);
    impl InstanceNetworkInterfaceViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InstanceNetworkInterface) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceNetworkInterfaceUpdateWhen(::httpmock::When);
    impl InstanceNetworkInterfaceUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/network-interfaces/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn interface(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/network-interfaces/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("instance", value.to_string()))
            } else {
                Self(self.0.query_param_missing("instance"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::InstanceNetworkInterfaceUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct InstanceNetworkInterfaceUpdateThen(::httpmock::Then);
    impl InstanceNetworkInterfaceUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InstanceNetworkInterface) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct InstanceNetworkInterfaceDeleteWhen(::httpmock::When);
    impl InstanceNetworkInterfaceDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/network-interfaces/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn interface(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/network-interfaces/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn instance<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("instance", value.to_string()))
            } else {
                Self(self.0.query_param_missing("instance"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct InstanceNetworkInterfaceDeleteThen(::httpmock::Then);
    impl InstanceNetworkInterfaceDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct PingWhen(::httpmock::When);
    impl PingWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/ping$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct PingThen(::httpmock::Then);
    impl PingThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Ping) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct PolicyViewWhen(::httpmock::When);
    impl PolicyViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct PolicyViewThen(::httpmock::Then);
    impl PolicyViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct PolicyUpdateWhen(::httpmock::When);
    impl PolicyUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SiloRolePolicy) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct PolicyUpdateThen(::httpmock::Then);
    impl PolicyUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectListWhen(::httpmock::When);
    impl ProjectListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/projects$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct ProjectListThen(::httpmock::Then);
    impl ProjectListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ProjectResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectCreateWhen(::httpmock::When);
    impl ProjectCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/projects$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::ProjectCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ProjectCreateThen(::httpmock::Then);
    impl ProjectCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Project) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectViewWhen(::httpmock::When);
    impl ProjectViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/projects/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/projects/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct ProjectViewThen(::httpmock::Then);
    impl ProjectViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Project) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectUpdateWhen(::httpmock::When);
    impl ProjectUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/projects/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/projects/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::ProjectUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ProjectUpdateThen(::httpmock::Then);
    impl ProjectUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Project) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectDeleteWhen(::httpmock::When);
    impl ProjectDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/projects/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/projects/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct ProjectDeleteThen(::httpmock::Then);
    impl ProjectDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectPolicyViewWhen(::httpmock::When);
    impl ProjectPolicyViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/projects/[^/]*/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/projects/{}/policy$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct ProjectPolicyViewThen(::httpmock::Then);
    impl ProjectPolicyViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ProjectRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ProjectPolicyUpdateWhen(::httpmock::When);
    impl ProjectPolicyUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/projects/[^/]*/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/projects/{}/policy$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::ProjectRolePolicy) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct ProjectPolicyUpdateThen(::httpmock::Then);
    impl ProjectPolicyUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ProjectRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SnapshotListWhen(::httpmock::When);
    impl SnapshotListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/snapshots$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SnapshotListThen(::httpmock::Then);
    impl SnapshotListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SnapshotResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SnapshotCreateWhen(::httpmock::When);
    impl SnapshotCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/snapshots$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::SnapshotCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SnapshotCreateThen(::httpmock::Then);
    impl SnapshotCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Snapshot) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SnapshotViewWhen(::httpmock::When);
    impl SnapshotViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/snapshots/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn snapshot(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/snapshots/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct SnapshotViewThen(::httpmock::Then);
    impl SnapshotViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Snapshot) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SnapshotDeleteWhen(::httpmock::When);
    impl SnapshotDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/snapshots/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn snapshot(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/snapshots/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct SnapshotDeleteThen(::httpmock::Then);
    impl SnapshotDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SubnetPoolListWhen(::httpmock::When);
    impl SubnetPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/subnet-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SubnetPoolListThen(::httpmock::Then);
    impl SubnetPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloSubnetPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SubnetPoolViewWhen(::httpmock::When);
    impl SubnetPoolViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/subnet-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/subnet-pools/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SubnetPoolViewThen(::httpmock::Then);
    impl SubnetPoolViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloSubnetPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct AuditLogListWhen(::httpmock::When);
    impl AuditLogListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/audit-log$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn end_time<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("end_time", value.to_string()))
            } else {
                Self(self.0.query_param_missing("end_time"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::TimeAndIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn start_time<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("start_time", value.to_string()))
            } else {
                Self(self.0.query_param_missing("start_time"))
            }
        }
    }

    pub struct AuditLogListThen(::httpmock::Then);
    impl AuditLogListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AuditLogEntryResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct PhysicalDiskListWhen(::httpmock::When);
    impl PhysicalDiskListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/disks$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct PhysicalDiskListThen(::httpmock::Then);
    impl PhysicalDiskListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::PhysicalDiskResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct PhysicalDiskViewWhen(::httpmock::When);
    impl PhysicalDiskViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/disks/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn disk_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/disks/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct PhysicalDiskViewThen(::httpmock::Then);
    impl PhysicalDiskViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::PhysicalDisk) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortLldpNeighborsWhen(::httpmock::When);
    impl NetworkingSwitchPortLldpNeighborsWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new(
                        "^/v1/system/hardware/rack-switch-port/[^/]*/[^/]*/[^/]*/lldp/neighbors$",
                    )
                    .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/rack-switch-port/{}/.*/.*/lldp/neighbors$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/rack-switch-port/.*/{}/.*/lldp/neighbors$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn port(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/rack-switch-port/.*/.*/{}/lldp/neighbors$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingSwitchPortLldpNeighborsThen(::httpmock::Then);
    impl NetworkingSwitchPortLldpNeighborsThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::LldpNeighborResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct RackListWhen(::httpmock::When);
    impl RackListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/racks$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct RackListThen(::httpmock::Then);
    impl RackListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RackResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct RackViewWhen(::httpmock::When);
    impl RackViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/racks/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/racks/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct RackViewThen(::httpmock::Then);
    impl RackViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Rack) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct RackMembershipStatusWhen(::httpmock::When);
    impl RackMembershipStatusWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/hardware/racks/[^/]*/membership$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/racks/{}/membership$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn version<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::RackMembershipVersion>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("version", value.to_string()))
            } else {
                Self(self.0.query_param_missing("version"))
            }
        }
    }

    pub struct RackMembershipStatusThen(::httpmock::Then);
    impl RackMembershipStatusThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RackMembershipStatus) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct RackMembershipAbortWhen(::httpmock::When);
    impl RackMembershipAbortWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/hardware/racks/[^/]*/membership/abort$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/racks/{}/membership/abort$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct RackMembershipAbortThen(::httpmock::Then);
    impl RackMembershipAbortThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RackMembershipStatus) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct RackMembershipAddSledsWhen(::httpmock::When);
    impl RackMembershipAddSledsWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/hardware/racks/[^/]*/membership/add$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/racks/{}/membership/add$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::RackMembershipAddSledsRequest) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct RackMembershipAddSledsThen(::httpmock::Then);
    impl RackMembershipAddSledsThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RackMembershipStatus) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledListWhen(::httpmock::When);
    impl SledListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/sleds$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SledListThen(::httpmock::Then);
    impl SledListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SledResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledAddWhen(::httpmock::When);
    impl SledAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/sleds$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::UninitializedSledId) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SledAddThen(::httpmock::Then);
    impl SledAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SledId) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledViewWhen(::httpmock::When);
    impl SledViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/sleds/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn sled_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/sleds/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SledViewThen(::httpmock::Then);
    impl SledViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Sled) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledPhysicalDiskListWhen(::httpmock::When);
    impl SledPhysicalDiskListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/hardware/sleds/[^/]*/disks$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn sled_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/sleds/{}/disks$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SledPhysicalDiskListThen(::httpmock::Then);
    impl SledPhysicalDiskListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::PhysicalDiskResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledInstanceListWhen(::httpmock::When);
    impl SledInstanceListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/hardware/sleds/[^/]*/instances$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn sled_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/sleds/{}/instances$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SledInstanceListThen(::httpmock::Then);
    impl SledInstanceListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SledInstanceResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledSetProvisionPolicyWhen(::httpmock::When);
    impl SledSetProvisionPolicyWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::PUT).path_matches(
                regex::Regex::new("^/v1/system/hardware/sleds/[^/]*/provision-policy$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn sled_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/sleds/{}/provision-policy$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SledProvisionPolicyParams) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SledSetProvisionPolicyThen(::httpmock::Then);
    impl SledSetProvisionPolicyThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SledProvisionPolicyResponse) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SledListUninitializedWhen(::httpmock::When);
    impl SledListUninitializedWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/hardware/sleds-uninitialized$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }
    }

    pub struct SledListUninitializedThen(::httpmock::Then);
    impl SledListUninitializedThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UninitializedSledResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortListWhen(::httpmock::When);
    impl NetworkingSwitchPortListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/switch-port$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn switch_port_id<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::uuid::Uuid>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("switch_port_id", value.to_string()))
            } else {
                Self(self.0.query_param_missing("switch_port_id"))
            }
        }
    }

    pub struct NetworkingSwitchPortListThen(::httpmock::Then);
    impl NetworkingSwitchPortListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SwitchPortResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortLldpConfigViewWhen(::httpmock::When);
    impl NetworkingSwitchPortLldpConfigViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/hardware/switch-port/[^/]*/lldp/config$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/switch-port/{}/lldp/config$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            Self(self.0.query_param("rack_id", value.to_string()))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            Self(self.0.query_param("switch_location", value.to_string()))
        }
    }

    pub struct NetworkingSwitchPortLldpConfigViewThen(::httpmock::Then);
    impl NetworkingSwitchPortLldpConfigViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::LldpLinkConfig) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortLldpConfigUpdateWhen(::httpmock::When);
    impl NetworkingSwitchPortLldpConfigUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/hardware/switch-port/[^/]*/lldp/config$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/switch-port/{}/lldp/config$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            Self(self.0.query_param("rack_id", value.to_string()))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            Self(self.0.query_param("switch_location", value.to_string()))
        }

        pub fn body(self, value: &types::LldpLinkConfig) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingSwitchPortLldpConfigUpdateThen(::httpmock::Then);
    impl NetworkingSwitchPortLldpConfigUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortApplySettingsWhen(::httpmock::When);
    impl NetworkingSwitchPortApplySettingsWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/hardware/switch-port/[^/]*/settings$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/switch-port/{}/settings$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            Self(self.0.query_param("rack_id", value.to_string()))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            Self(self.0.query_param("switch_location", value.to_string()))
        }

        pub fn body(self, value: &types::SwitchPortApplySettings) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingSwitchPortApplySettingsThen(::httpmock::Then);
    impl NetworkingSwitchPortApplySettingsThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortClearSettingsWhen(::httpmock::When);
    impl NetworkingSwitchPortClearSettingsWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/hardware/switch-port/[^/]*/settings$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/switch-port/{}/settings$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            Self(self.0.query_param("rack_id", value.to_string()))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            Self(self.0.query_param("switch_location", value.to_string()))
        }
    }

    pub struct NetworkingSwitchPortClearSettingsThen(::httpmock::Then);
    impl NetworkingSwitchPortClearSettingsThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortStatusWhen(::httpmock::When);
    impl NetworkingSwitchPortStatusWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/hardware/switch-port/[^/]*/status$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/switch-port/{}/status$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            Self(self.0.query_param("rack_id", value.to_string()))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            Self(self.0.query_param("switch_location", value.to_string()))
        }
    }

    pub struct NetworkingSwitchPortStatusThen(::httpmock::Then);
    impl NetworkingSwitchPortStatusThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SwitchLinkState) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SwitchListWhen(::httpmock::When);
    impl SwitchListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/hardware/switches$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SwitchListThen(::httpmock::Then);
    impl SwitchListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SwitchResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SwitchViewWhen(::httpmock::When);
    impl SwitchViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/hardware/switches/[^/]*$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn switch_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/hardware/switches/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SwitchViewThen(::httpmock::Then);
    impl SwitchViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Switch) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloIdentityProviderListWhen(::httpmock::When);
    impl SiloIdentityProviderListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/identity-providers$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn silo<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("silo", value.to_string()))
            } else {
                Self(self.0.query_param_missing("silo"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SiloIdentityProviderListThen(::httpmock::Then);
    impl SiloIdentityProviderListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IdentityProviderResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct LocalIdpUserCreateWhen(::httpmock::When);
    impl LocalIdpUserCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/identity-providers/local/users$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }

        pub fn body(self, value: &types::UserCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct LocalIdpUserCreateThen(::httpmock::Then);
    impl LocalIdpUserCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::User) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct LocalIdpUserDeleteWhen(::httpmock::When);
    impl LocalIdpUserDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/identity-providers/local/users/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/identity-providers/local/users/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }
    }

    pub struct LocalIdpUserDeleteThen(::httpmock::Then);
    impl LocalIdpUserDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct LocalIdpUserSetPasswordWhen(::httpmock::When);
    impl LocalIdpUserSetPasswordWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new(
                        "^/v1/system/identity-providers/local/users/[^/]*/set-password$",
                    )
                    .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/identity-providers/local/users/{}/set-password$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }

        pub fn body(self, value: &types::UserPassword) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct LocalIdpUserSetPasswordThen(::httpmock::Then);
    impl LocalIdpUserSetPasswordThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SamlIdentityProviderCreateWhen(::httpmock::When);
    impl SamlIdentityProviderCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/system/identity-providers/saml$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }

        pub fn body(self, value: &types::SamlIdentityProviderCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SamlIdentityProviderCreateThen(::httpmock::Then);
    impl SamlIdentityProviderCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SamlIdentityProvider) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SamlIdentityProviderViewWhen(::httpmock::When);
    impl SamlIdentityProviderViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/identity-providers/saml/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn provider(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/identity-providers/saml/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("silo", value.to_string()))
            } else {
                Self(self.0.query_param_missing("silo"))
            }
        }
    }

    pub struct SamlIdentityProviderViewThen(::httpmock::Then);
    impl SamlIdentityProviderViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SamlIdentityProvider) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolListWhen(::httpmock::When);
    impl SystemIpPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemIpPoolListThen(::httpmock::Then);
    impl SystemIpPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolCreateWhen(::httpmock::When);
    impl SystemIpPoolCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::IpPoolCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolCreateThen(::httpmock::Then);
    impl SystemIpPoolCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::IpPool) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolViewWhen(::httpmock::When);
    impl SystemIpPoolViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/ip-pools/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemIpPoolViewThen(::httpmock::Then);
    impl SystemIpPoolViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolUpdateWhen(::httpmock::When);
    impl SystemIpPoolUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/ip-pools/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::IpPoolUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolUpdateThen(::httpmock::Then);
    impl SystemIpPoolUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolDeleteWhen(::httpmock::When);
    impl SystemIpPoolDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/ip-pools/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemIpPoolDeleteThen(::httpmock::Then);
    impl SystemIpPoolDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolRangeListWhen(::httpmock::When);
    impl SystemIpPoolRangeListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools/[^/]*/ranges$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/ranges$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }
    }

    pub struct SystemIpPoolRangeListThen(::httpmock::Then);
    impl SystemIpPoolRangeListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPoolRangeResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolRangeAddWhen(::httpmock::When);
    impl SystemIpPoolRangeAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/system/ip-pools/[^/]*/ranges/add$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/ranges/add$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::IpRange) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolRangeAddThen(::httpmock::Then);
    impl SystemIpPoolRangeAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::IpPoolRange) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolRangeRemoveWhen(::httpmock::When);
    impl SystemIpPoolRangeRemoveWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/ip-pools/[^/]*/ranges/remove$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/ranges/remove$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::IpRange) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolRangeRemoveThen(::httpmock::Then);
    impl SystemIpPoolRangeRemoveThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolSiloListWhen(::httpmock::When);
    impl SystemIpPoolSiloListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools/[^/]*/silos$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/silos$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemIpPoolSiloListThen(::httpmock::Then);
    impl SystemIpPoolSiloListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPoolSiloLinkResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolSiloLinkWhen(::httpmock::When);
    impl SystemIpPoolSiloLinkWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools/[^/]*/silos$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/silos$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::IpPoolLinkSilo) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolSiloLinkThen(::httpmock::Then);
    impl SystemIpPoolSiloLinkThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::IpPoolSiloLink) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolSiloUpdateWhen(::httpmock::When);
    impl SystemIpPoolSiloUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::PUT).path_matches(
                regex::Regex::new("^/v1/system/ip-pools/[^/]*/silos/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/silos/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/.*/silos/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::IpPoolSiloUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolSiloUpdateThen(::httpmock::Then);
    impl SystemIpPoolSiloUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPoolSiloLink) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolSiloUnlinkWhen(::httpmock::When);
    impl SystemIpPoolSiloUnlinkWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/ip-pools/[^/]*/silos/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/silos/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/.*/silos/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemIpPoolSiloUnlinkThen(::httpmock::Then);
    impl SystemIpPoolSiloUnlinkThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolUtilizationViewWhen(::httpmock::When);
    impl SystemIpPoolUtilizationViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/ip-pools/[^/]*/utilization$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/ip-pools/{}/utilization$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemIpPoolUtilizationViewThen(::httpmock::Then);
    impl SystemIpPoolUtilizationViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPoolUtilization) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolServiceViewWhen(::httpmock::When);
    impl SystemIpPoolServiceViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/ip-pools-service$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct SystemIpPoolServiceViewThen(::httpmock::Then);
    impl SystemIpPoolServiceViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolServiceRangeListWhen(::httpmock::When);
    impl SystemIpPoolServiceRangeListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/ip-pools-service/ranges$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }
    }

    pub struct SystemIpPoolServiceRangeListThen(::httpmock::Then);
    impl SystemIpPoolServiceRangeListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::IpPoolRangeResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolServiceRangeAddWhen(::httpmock::When);
    impl SystemIpPoolServiceRangeAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/ip-pools-service/ranges/add$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::IpRange) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolServiceRangeAddThen(::httpmock::Then);
    impl SystemIpPoolServiceRangeAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::IpPoolRange) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemIpPoolServiceRangeRemoveWhen(::httpmock::When);
    impl SystemIpPoolServiceRangeRemoveWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/ip-pools-service/ranges/remove$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::IpRange) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemIpPoolServiceRangeRemoveThen(::httpmock::Then);
    impl SystemIpPoolServiceRangeRemoveThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemMetricWhen(::httpmock::When);
    impl SystemMetricWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/metrics/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn metric_name(self, value: types::SystemMetricName) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/metrics/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn end_time<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("end_time", value.to_string()))
            } else {
                Self(self.0.query_param_missing("end_time"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn order<T>(self, value: T) -> Self
        where
            T: Into<Option<types::PaginationOrder>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("order", value.to_string()))
            } else {
                Self(self.0.query_param_missing("order"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn silo<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("silo", value.to_string()))
            } else {
                Self(self.0.query_param_missing("silo"))
            }
        }

        pub fn start_time<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("start_time", value.to_string()))
            } else {
                Self(self.0.query_param_missing("start_time"))
            }
        }
    }

    pub struct SystemMetricThen(::httpmock::Then);
    impl SystemMetricThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::MeasurementResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAddressLotListWhen(::httpmock::When);
    impl NetworkingAddressLotListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/networking/address-lot$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingAddressLotListThen(::httpmock::Then);
    impl NetworkingAddressLotListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AddressLotResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAddressLotCreateWhen(::httpmock::When);
    impl NetworkingAddressLotCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/system/networking/address-lot$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::AddressLotCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingAddressLotCreateThen(::httpmock::Then);
    impl NetworkingAddressLotCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::AddressLotCreateResponse) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAddressLotViewWhen(::httpmock::When);
    impl NetworkingAddressLotViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/address-lot/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn address_lot(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/address-lot/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct NetworkingAddressLotViewThen(::httpmock::Then);
    impl NetworkingAddressLotViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AddressLotViewResponse) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAddressLotDeleteWhen(::httpmock::When);
    impl NetworkingAddressLotDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/networking/address-lot/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn address_lot(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/address-lot/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct NetworkingAddressLotDeleteThen(::httpmock::Then);
    impl NetworkingAddressLotDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAddressLotBlockListWhen(::httpmock::When);
    impl NetworkingAddressLotBlockListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/address-lot/[^/]*/blocks$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn address_lot(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/address-lot/{}/blocks$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingAddressLotBlockListThen(::httpmock::Then);
    impl NetworkingAddressLotBlockListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AddressLotBlockResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAllowListViewWhen(::httpmock::When);
    impl NetworkingAllowListViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/networking/allow-list$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct NetworkingAllowListViewThen(::httpmock::Then);
    impl NetworkingAllowListViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AllowList) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingAllowListUpdateWhen(::httpmock::When);
    impl NetworkingAllowListUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/networking/allow-list$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::AllowListUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingAllowListUpdateThen(::httpmock::Then);
    impl NetworkingAllowListUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AllowList) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBfdDisableWhen(::httpmock::When);
    impl NetworkingBfdDisableWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/system/networking/bfd-disable$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::BfdSessionDisable) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingBfdDisableThen(::httpmock::Then);
    impl NetworkingBfdDisableThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBfdEnableWhen(::httpmock::When);
    impl NetworkingBfdEnableWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/networking/bfd-enable$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::BfdSessionEnable) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingBfdEnableThen(::httpmock::Then);
    impl NetworkingBfdEnableThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBfdStatusWhen(::httpmock::When);
    impl NetworkingBfdStatusWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/networking/bfd-status$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct NetworkingBfdStatusThen(::httpmock::Then);
    impl NetworkingBfdStatusThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::BfdStatus>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpConfigListWhen(::httpmock::When);
    impl NetworkingBgpConfigListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/networking/bgp$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingBgpConfigListThen(::httpmock::Then);
    impl NetworkingBgpConfigListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::BgpConfigResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpConfigCreateWhen(::httpmock::When);
    impl NetworkingBgpConfigCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/networking/bgp$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::BgpConfigCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingBgpConfigCreateThen(::httpmock::Then);
    impl NetworkingBgpConfigCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::BgpConfig) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpConfigDeleteWhen(::httpmock::When);
    impl NetworkingBgpConfigDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/system/networking/bgp$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn name_or_id(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("name_or_id", value.to_string()))
        }
    }

    pub struct NetworkingBgpConfigDeleteThen(::httpmock::Then);
    impl NetworkingBgpConfigDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpAnnounceSetListWhen(::httpmock::When);
    impl NetworkingBgpAnnounceSetListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/bgp-announce-set$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingBgpAnnounceSetListThen(::httpmock::Then);
    impl NetworkingBgpAnnounceSetListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::BgpAnnounceSet>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpAnnounceSetUpdateWhen(::httpmock::When);
    impl NetworkingBgpAnnounceSetUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::PUT).path_matches(
                regex::Regex::new("^/v1/system/networking/bgp-announce-set$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::BgpAnnounceSetCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingBgpAnnounceSetUpdateThen(::httpmock::Then);
    impl NetworkingBgpAnnounceSetUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::BgpAnnounceSet) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpAnnounceSetDeleteWhen(::httpmock::When);
    impl NetworkingBgpAnnounceSetDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/networking/bgp-announce-set/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn announce_set(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/bgp-announce-set/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct NetworkingBgpAnnounceSetDeleteThen(::httpmock::Then);
    impl NetworkingBgpAnnounceSetDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpAnnouncementListWhen(::httpmock::When);
    impl NetworkingBgpAnnouncementListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new(
                        "^/v1/system/networking/bgp-announce-set/[^/]*/announcement$",
                    )
                    .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn announce_set(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/bgp-announce-set/{}/announcement$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct NetworkingBgpAnnouncementListThen(::httpmock::Then);
    impl NetworkingBgpAnnouncementListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::BgpAnnouncement>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpExportedWhen(::httpmock::When);
    impl NetworkingBgpExportedWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/networking/bgp-exported$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct NetworkingBgpExportedThen(::httpmock::Then);
    impl NetworkingBgpExportedThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::BgpExported>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpImportedWhen(::httpmock::When);
    impl NetworkingBgpImportedWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/networking/bgp-imported$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn asn(self, value: u32) -> Self {
            Self(self.0.query_param("asn", value.to_string()))
        }
    }

    pub struct NetworkingBgpImportedThen(::httpmock::Then);
    impl NetworkingBgpImportedThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::BgpImported>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpMessageHistoryWhen(::httpmock::When);
    impl NetworkingBgpMessageHistoryWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/bgp-message-history$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn asn(self, value: u32) -> Self {
            Self(self.0.query_param("asn", value.to_string()))
        }
    }

    pub struct NetworkingBgpMessageHistoryThen(::httpmock::Then);
    impl NetworkingBgpMessageHistoryThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::AggregateBgpMessageHistory) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingBgpStatusWhen(::httpmock::When);
    impl NetworkingBgpStatusWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/networking/bgp-status$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct NetworkingBgpStatusThen(::httpmock::Then);
    impl NetworkingBgpStatusThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::BgpPeerStatus>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingInboundIcmpViewWhen(::httpmock::When);
    impl NetworkingInboundIcmpViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/networking/inbound-icmp$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct NetworkingInboundIcmpViewThen(::httpmock::Then);
    impl NetworkingInboundIcmpViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ServiceIcmpConfig) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingInboundIcmpUpdateWhen(::httpmock::When);
    impl NetworkingInboundIcmpUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::PUT).path_matches(
                    regex::Regex::new("^/v1/system/networking/inbound-icmp$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::ServiceIcmpConfig) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingInboundIcmpUpdateThen(::httpmock::Then);
    impl NetworkingInboundIcmpUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingLoopbackAddressListWhen(::httpmock::When);
    impl NetworkingLoopbackAddressListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/loopback-address$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingLoopbackAddressListThen(::httpmock::Then);
    impl NetworkingLoopbackAddressListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::LoopbackAddressResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingLoopbackAddressCreateWhen(::httpmock::When);
    impl NetworkingLoopbackAddressCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/networking/loopback-address$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::LoopbackAddressCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingLoopbackAddressCreateThen(::httpmock::Then);
    impl NetworkingLoopbackAddressCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::LoopbackAddress) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingLoopbackAddressDeleteWhen(::httpmock::When);
    impl NetworkingLoopbackAddressDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::DELETE).path_matches(
                    regex::Regex::new(
                        "^/v1/system/networking/loopback-address/[^/]*/[^/]*/[^/]*/[^/]*$",
                    )
                    .unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn rack_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/loopback-address/{}/.*/.*/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn switch_location(self, value: &types::Name) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/loopback-address/.*/{}/.*/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn address(self, value: &::std::net::IpAddr) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/loopback-address/.*/.*/{}/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn subnet_mask(self, value: u8) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/loopback-address/.*/.*/.*/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct NetworkingLoopbackAddressDeleteThen(::httpmock::Then);
    impl NetworkingLoopbackAddressDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortSettingsListWhen(::httpmock::When);
    impl NetworkingSwitchPortSettingsListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/switch-port-settings$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn port_settings<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("port_settings", value.to_string()))
            } else {
                Self(self.0.query_param_missing("port_settings"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct NetworkingSwitchPortSettingsListThen(::httpmock::Then);
    impl NetworkingSwitchPortSettingsListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SwitchPortSettingsIdentityResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortSettingsCreateWhen(::httpmock::When);
    impl NetworkingSwitchPortSettingsCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/networking/switch-port-settings$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SwitchPortSettingsCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct NetworkingSwitchPortSettingsCreateThen(::httpmock::Then);
    impl NetworkingSwitchPortSettingsCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SwitchPortSettings) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortSettingsDeleteWhen(::httpmock::When);
    impl NetworkingSwitchPortSettingsDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/networking/switch-port-settings$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port_settings<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("port_settings", value.to_string()))
            } else {
                Self(self.0.query_param_missing("port_settings"))
            }
        }
    }

    pub struct NetworkingSwitchPortSettingsDeleteThen(::httpmock::Then);
    impl NetworkingSwitchPortSettingsDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct NetworkingSwitchPortSettingsViewWhen(::httpmock::When);
    impl NetworkingSwitchPortSettingsViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/networking/switch-port-settings/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn port(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/networking/switch-port-settings/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct NetworkingSwitchPortSettingsViewThen(::httpmock::Then);
    impl NetworkingSwitchPortSettingsViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SwitchPortSettings) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemPolicyViewWhen(::httpmock::When);
    impl SystemPolicyViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct SystemPolicyViewThen(::httpmock::Then);
    impl SystemPolicyViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::FleetRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemPolicyUpdateWhen(::httpmock::When);
    impl SystemPolicyUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::FleetRolePolicy) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemPolicyUpdateThen(::httpmock::Then);
    impl SystemPolicyUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::FleetRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ScimTokenListWhen(::httpmock::When);
    impl ScimTokenListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/scim/tokens$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }
    }

    pub struct ScimTokenListThen(::httpmock::Then);
    impl ScimTokenListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &::std::vec::Vec<types::ScimClientBearerToken>) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ScimTokenCreateWhen(::httpmock::When);
    impl ScimTokenCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/scim/tokens$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }
    }

    pub struct ScimTokenCreateThen(::httpmock::Then);
    impl ScimTokenCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::ScimClientBearerTokenValue) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ScimTokenViewWhen(::httpmock::When);
    impl ScimTokenViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/scim/tokens/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn token_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/scim/tokens/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }
    }

    pub struct ScimTokenViewThen(::httpmock::Then);
    impl ScimTokenViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ScimClientBearerToken) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct ScimTokenDeleteWhen(::httpmock::When);
    impl ScimTokenDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/system/scim/tokens/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn token_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/scim/tokens/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }
    }

    pub struct ScimTokenDeleteThen(::httpmock::Then);
    impl ScimTokenDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemQuotasListWhen(::httpmock::When);
    impl SystemQuotasListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/silo-quotas$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemQuotasListThen(::httpmock::Then);
    impl SystemQuotasListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloQuotasResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloListWhen(::httpmock::When);
    impl SiloListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/silos$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SiloListThen(::httpmock::Then);
    impl SiloListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloCreateWhen(::httpmock::When);
    impl SiloCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/silos$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SiloCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SiloCreateThen(::httpmock::Then);
    impl SiloCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Silo) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloViewWhen(::httpmock::When);
    impl SiloViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/silos/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SiloViewThen(::httpmock::Then);
    impl SiloViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Silo) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloDeleteWhen(::httpmock::When);
    impl SiloDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/silos/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SiloDeleteThen(::httpmock::Then);
    impl SiloDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloIpPoolListWhen(::httpmock::When);
    impl SiloIpPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*/ip-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/silos/{}/ip-pools$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SiloIpPoolListThen(::httpmock::Then);
    impl SiloIpPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloIpPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloPolicyViewWhen(::httpmock::When);
    impl SiloPolicyViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/silos/{}/policy$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SiloPolicyViewThen(::httpmock::Then);
    impl SiloPolicyViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloPolicyUpdateWhen(::httpmock::When);
    impl SiloPolicyUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*/policy$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/silos/{}/policy$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SiloRolePolicy) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SiloPolicyUpdateThen(::httpmock::Then);
    impl SiloPolicyUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloRolePolicy) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloQuotasViewWhen(::httpmock::When);
    impl SiloQuotasViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*/quotas$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/silos/{}/quotas$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SiloQuotasViewThen(::httpmock::Then);
    impl SiloQuotasViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloQuotas) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloQuotasUpdateWhen(::httpmock::When);
    impl SiloQuotasUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/silos/[^/]*/quotas$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/silos/{}/quotas$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SiloQuotasUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SiloQuotasUpdateThen(::httpmock::Then);
    impl SiloQuotasUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloQuotas) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloSubnetPoolListWhen(::httpmock::When);
    impl SiloSubnetPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/silos/[^/]*/subnet-pools$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/silos/{}/subnet-pools$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SiloSubnetPoolListThen(::httpmock::Then);
    impl SiloSubnetPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloSubnetPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolListWhen(::httpmock::When);
    impl SystemSubnetPoolListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/subnet-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemSubnetPoolListThen(::httpmock::Then);
    impl SystemSubnetPoolListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPoolResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolCreateWhen(::httpmock::When);
    impl SystemSubnetPoolCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/subnet-pools$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SubnetPoolCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemSubnetPoolCreateThen(::httpmock::Then);
    impl SystemSubnetPoolCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SubnetPool) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolViewWhen(::httpmock::When);
    impl SystemSubnetPoolViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/subnet-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/subnet-pools/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemSubnetPoolViewThen(::httpmock::Then);
    impl SystemSubnetPoolViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolUpdateWhen(::httpmock::When);
    impl SystemSubnetPoolUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/subnet-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/subnet-pools/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SubnetPoolUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemSubnetPoolUpdateThen(::httpmock::Then);
    impl SystemSubnetPoolUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPool) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolDeleteWhen(::httpmock::When);
    impl SystemSubnetPoolDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/system/subnet-pools/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/system/subnet-pools/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemSubnetPoolDeleteThen(::httpmock::Then);
    impl SystemSubnetPoolDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolMemberListWhen(::httpmock::When);
    impl SystemSubnetPoolMemberListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/subnet-pools/[^/]*/members$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/members$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }
    }

    pub struct SystemSubnetPoolMemberListThen(::httpmock::Then);
    impl SystemSubnetPoolMemberListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPoolMemberResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolMemberAddWhen(::httpmock::When);
    impl SystemSubnetPoolMemberAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/subnet-pools/[^/]*/members/add$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/members/add$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SubnetPoolMemberAdd) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemSubnetPoolMemberAddThen(::httpmock::Then);
    impl SystemSubnetPoolMemberAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SubnetPoolMember) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolMemberRemoveWhen(::httpmock::When);
    impl SystemSubnetPoolMemberRemoveWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::POST).path_matches(
                regex::Regex::new("^/v1/system/subnet-pools/[^/]*/members/remove$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/members/remove$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SubnetPoolMemberRemove) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemSubnetPoolMemberRemoveThen(::httpmock::Then);
    impl SystemSubnetPoolMemberRemoveThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolSiloListWhen(::httpmock::When);
    impl SystemSubnetPoolSiloListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/subnet-pools/[^/]*/silos$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/silos$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemSubnetPoolSiloListThen(::httpmock::Then);
    impl SystemSubnetPoolSiloListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPoolSiloLinkResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolSiloLinkWhen(::httpmock::When);
    impl SystemSubnetPoolSiloLinkWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::POST).path_matches(
                    regex::Regex::new("^/v1/system/subnet-pools/[^/]*/silos$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/silos$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SubnetPoolLinkSilo) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemSubnetPoolSiloLinkThen(::httpmock::Then);
    impl SystemSubnetPoolSiloLinkThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::SubnetPoolSiloLink) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolSiloUpdateWhen(::httpmock::When);
    impl SystemSubnetPoolSiloUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::PUT).path_matches(
                regex::Regex::new("^/v1/system/subnet-pools/[^/]*/silos/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/silos/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/.*/silos/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::SubnetPoolSiloUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemSubnetPoolSiloUpdateThen(::httpmock::Then);
    impl SystemSubnetPoolSiloUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPoolSiloLink) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolSiloUnlinkWhen(::httpmock::When);
    impl SystemSubnetPoolSiloUnlinkWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::DELETE).path_matches(
                regex::Regex::new("^/v1/system/subnet-pools/[^/]*/silos/[^/]*$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/silos/.*$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/.*/silos/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemSubnetPoolSiloUnlinkThen(::httpmock::Then);
    impl SystemSubnetPoolSiloUnlinkThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemSubnetPoolUtilizationViewWhen(::httpmock::When);
    impl SystemSubnetPoolUtilizationViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/system/subnet-pools/[^/]*/utilization$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn pool(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/subnet-pools/{}/utilization$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemSubnetPoolUtilizationViewThen(::httpmock::Then);
    impl SystemSubnetPoolUtilizationViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SubnetPoolUtilization) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemTimeseriesQueryWhen(::httpmock::When);
    impl SystemTimeseriesQueryWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/timeseries/query$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::TimeseriesQuery) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemTimeseriesQueryThen(::httpmock::Then);
    impl SystemTimeseriesQueryThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::OxqlQueryResult) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemTimeseriesSchemaListWhen(::httpmock::When);
    impl SystemTimeseriesSchemaListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/timeseries/schemas$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }
    }

    pub struct SystemTimeseriesSchemaListThen(::httpmock::Then);
    impl SystemTimeseriesSchemaListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::TimeseriesSchemaResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateRepositoryListWhen(::httpmock::When);
    impl SystemUpdateRepositoryListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/update/repositories$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::VersionSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemUpdateRepositoryListThen(::httpmock::Then);
    impl SystemUpdateRepositoryListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::TufRepoResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateRepositoryUploadWhen(::httpmock::When);
    impl SystemUpdateRepositoryUploadWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/update/repositories$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn file_name(self, value: &str) -> Self {
            Self(self.0.query_param("file_name", value.to_string()))
        }

        pub fn body(self, value: ::serde_json::Value) -> Self {
            Self(self.0.json_body(value))
        }
    }

    pub struct SystemUpdateRepositoryUploadThen(::httpmock::Then);
    impl SystemUpdateRepositoryUploadThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::TufRepoUpload) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateRepositoryViewWhen(::httpmock::When);
    impl SystemUpdateRepositoryViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/update/repositories/[^/]*$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn system_version(
            self,
            value: &types::SystemUpdateRepositoryViewSystemVersion,
        ) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/update/repositories/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemUpdateRepositoryViewThen(::httpmock::Then);
    impl SystemUpdateRepositoryViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::TufRepo) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateStatusWhen(::httpmock::When);
    impl SystemUpdateStatusWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/update/status$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct SystemUpdateStatusThen(::httpmock::Then);
    impl SystemUpdateStatusThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UpdateStatus) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct TargetReleaseUpdateWhen(::httpmock::When);
    impl TargetReleaseUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/system/update/target-release$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::SetTargetReleaseParams) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct TargetReleaseUpdateThen(::httpmock::Then);
    impl TargetReleaseUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateTrustRootListWhen(::httpmock::When);
    impl SystemUpdateTrustRootListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/update/trust-roots$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SystemUpdateTrustRootListThen(::httpmock::Then);
    impl SystemUpdateTrustRootListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UpdatesTrustRootResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateTrustRootCreateWhen(::httpmock::When);
    impl SystemUpdateTrustRootCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/system/update/trust-roots$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &::serde_json::Value) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct SystemUpdateTrustRootCreateThen(::httpmock::Then);
    impl SystemUpdateTrustRootCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::UpdatesTrustRoot) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateTrustRootViewWhen(::httpmock::When);
    impl SystemUpdateTrustRootViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/update/trust-roots/[^/]*$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn trust_root_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/update/trust-roots/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemUpdateTrustRootViewThen(::httpmock::Then);
    impl SystemUpdateTrustRootViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UpdatesTrustRoot) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SystemUpdateTrustRootDeleteWhen(::httpmock::When);
    impl SystemUpdateTrustRootDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::DELETE).path_matches(
                    regex::Regex::new("^/v1/system/update/trust-roots/[^/]*$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn trust_root_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/update/trust-roots/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SystemUpdateTrustRootDeleteThen(::httpmock::Then);
    impl SystemUpdateTrustRootDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloUserListWhen(::httpmock::When);
    impl SiloUserListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/users$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn silo<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("silo", value.to_string()))
            } else {
                Self(self.0.query_param_missing("silo"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SiloUserListThen(::httpmock::Then);
    impl SiloUserListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UserResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloUserViewWhen(::httpmock::When);
    impl SiloUserViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/users/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/users/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("silo", value.to_string()))
        }
    }

    pub struct SiloUserViewThen(::httpmock::Then);
    impl SiloUserViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::User) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserBuiltinListWhen(::httpmock::When);
    impl UserBuiltinListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/users-builtin$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct UserBuiltinListThen(::httpmock::Then);
    impl UserBuiltinListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UserBuiltinResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserBuiltinViewWhen(::httpmock::When);
    impl UserBuiltinViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/users-builtin/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/system/users-builtin/{}$", value.to_string()))
                    .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct UserBuiltinViewThen(::httpmock::Then);
    impl UserBuiltinViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UserBuiltin) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloUtilizationListWhen(::httpmock::When);
    impl SiloUtilizationListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/system/utilization/silos$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct SiloUtilizationListThen(::httpmock::Then);
    impl SiloUtilizationListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloUtilizationResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct SiloUtilizationViewWhen(::httpmock::When);
    impl SiloUtilizationViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner.method(::httpmock::Method::GET).path_matches(
                    regex::Regex::new("^/v1/system/utilization/silos/[^/]*$").unwrap(),
                ),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn silo(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/system/utilization/silos/{}$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct SiloUtilizationViewThen(::httpmock::Then);
    impl SiloUtilizationViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::SiloUtilization) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct TimeseriesQueryWhen(::httpmock::When);
    impl TimeseriesQueryWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/timeseries/query$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::TimeseriesQuery) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct TimeseriesQueryThen(::httpmock::Then);
    impl TimeseriesQueryThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::OxqlQueryResult) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserListWhen(::httpmock::When);
    impl UserListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/users$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn group<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a ::uuid::Uuid>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("group", value.to_string()))
            } else {
                Self(self.0.query_param_missing("group"))
            }
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct UserListThen(::httpmock::Then);
    impl UserListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::UserResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserViewWhen(::httpmock::When);
    impl UserViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/users/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!("^/v1/users/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct UserViewThen(::httpmock::Then);
    impl UserViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::User) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserTokenListWhen(::httpmock::When);
    impl UserTokenListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/users/[^/]*/access-tokens$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re = regex::Regex::new(&format!("^/v1/users/{}/access-tokens$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct UserTokenListThen(::httpmock::Then);
    impl UserTokenListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::DeviceAccessTokenResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserLogoutWhen(::httpmock::When);
    impl UserLogoutWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/users/[^/]*/logout$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/users/{}/logout$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct UserLogoutThen(::httpmock::Then);
    impl UserLogoutThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UserSessionListWhen(::httpmock::When);
    impl UserSessionListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/users/[^/]*/sessions$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn user_id(self, value: &::uuid::Uuid) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/users/{}/sessions$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::IdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct UserSessionListThen(::httpmock::Then);
    impl UserSessionListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::ConsoleSessionResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct UtilizationViewWhen(::httpmock::When);
    impl UtilizationViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/utilization$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }
    }

    pub struct UtilizationViewThen(::httpmock::Then);
    impl UtilizationViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Utilization) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcFirewallRulesViewWhen(::httpmock::When);
    impl VpcFirewallRulesViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-firewall-rules$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("vpc", value.to_string()))
        }
    }

    pub struct VpcFirewallRulesViewThen(::httpmock::Then);
    impl VpcFirewallRulesViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcFirewallRules) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcFirewallRulesUpdateWhen(::httpmock::When);
    impl VpcFirewallRulesUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/vpc-firewall-rules$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("vpc", value.to_string()))
        }

        pub fn body(self, value: &types::VpcFirewallRuleUpdateParams) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcFirewallRulesUpdateThen(::httpmock::Then);
    impl VpcFirewallRulesUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcFirewallRules) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterRouteListWhen(::httpmock::When);
    impl VpcRouterRouteListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-router-routes$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn router<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("router", value.to_string()))
            } else {
                Self(self.0.query_param_missing("router"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcRouterRouteListThen(::httpmock::Then);
    impl VpcRouterRouteListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RouterRouteResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterRouteCreateWhen(::httpmock::When);
    impl VpcRouterRouteCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/vpc-router-routes$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn router(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("router", value.to_string()))
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }

        pub fn body(self, value: &types::RouterRouteCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcRouterRouteCreateThen(::httpmock::Then);
    impl VpcRouterRouteCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::RouterRoute) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterRouteViewWhen(::httpmock::When);
    impl VpcRouterRouteViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-router-routes/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn route(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/vpc-router-routes/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn router<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("router", value.to_string()))
            } else {
                Self(self.0.query_param_missing("router"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcRouterRouteViewThen(::httpmock::Then);
    impl VpcRouterRouteViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RouterRoute) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterRouteUpdateWhen(::httpmock::When);
    impl VpcRouterRouteUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/vpc-router-routes/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn route(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/vpc-router-routes/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn router<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("router", value.to_string()))
            } else {
                Self(self.0.query_param_missing("router"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }

        pub fn body(self, value: &types::RouterRouteUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcRouterRouteUpdateThen(::httpmock::Then);
    impl VpcRouterRouteUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::RouterRoute) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterRouteDeleteWhen(::httpmock::When);
    impl VpcRouterRouteDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/vpc-router-routes/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn route(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/vpc-router-routes/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn router<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("router", value.to_string()))
            } else {
                Self(self.0.query_param_missing("router"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcRouterRouteDeleteThen(::httpmock::Then);
    impl VpcRouterRouteDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterListWhen(::httpmock::When);
    impl VpcRouterListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-routers$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcRouterListThen(::httpmock::Then);
    impl VpcRouterListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcRouterResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterCreateWhen(::httpmock::When);
    impl VpcRouterCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/vpc-routers$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("vpc", value.to_string()))
        }

        pub fn body(self, value: &types::VpcRouterCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcRouterCreateThen(::httpmock::Then);
    impl VpcRouterCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::VpcRouter) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterViewWhen(::httpmock::When);
    impl VpcRouterViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-routers/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn router(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/vpc-routers/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcRouterViewThen(::httpmock::Then);
    impl VpcRouterViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcRouter) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterUpdateWhen(::httpmock::When);
    impl VpcRouterUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/vpc-routers/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn router(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/vpc-routers/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }

        pub fn body(self, value: &types::VpcRouterUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcRouterUpdateThen(::httpmock::Then);
    impl VpcRouterUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcRouter) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcRouterDeleteWhen(::httpmock::When);
    impl VpcRouterDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/vpc-routers/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn router(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/vpc-routers/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcRouterDeleteThen(::httpmock::Then);
    impl VpcRouterDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcSubnetListWhen(::httpmock::When);
    impl VpcSubnetListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-subnets$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcSubnetListThen(::httpmock::Then);
    impl VpcSubnetListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcSubnetResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcSubnetCreateWhen(::httpmock::When);
    impl VpcSubnetCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/vpc-subnets$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("vpc", value.to_string()))
        }

        pub fn body(self, value: &types::VpcSubnetCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcSubnetCreateThen(::httpmock::Then);
    impl VpcSubnetCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::VpcSubnet) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcSubnetViewWhen(::httpmock::When);
    impl VpcSubnetViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpc-subnets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn subnet(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/vpc-subnets/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcSubnetViewThen(::httpmock::Then);
    impl VpcSubnetViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcSubnet) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcSubnetUpdateWhen(::httpmock::When);
    impl VpcSubnetUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/vpc-subnets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn subnet(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/vpc-subnets/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }

        pub fn body(self, value: &types::VpcSubnetUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcSubnetUpdateThen(::httpmock::Then);
    impl VpcSubnetUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcSubnet) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcSubnetDeleteWhen(::httpmock::When);
    impl VpcSubnetDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/vpc-subnets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn subnet(self, value: &types::NameOrId) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/vpc-subnets/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcSubnetDeleteThen(::httpmock::Then);
    impl VpcSubnetDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcSubnetListNetworkInterfacesWhen(::httpmock::When);
    impl VpcSubnetListNetworkInterfacesWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(inner.method(::httpmock::Method::GET).path_matches(
                regex::Regex::new("^/v1/vpc-subnets/[^/]*/network-interfaces$").unwrap(),
            ))
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn subnet(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!(
                "^/v1/vpc-subnets/{}/network-interfaces$",
                value.to_string()
            ))
            .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }

        pub fn vpc<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("vpc", value.to_string()))
            } else {
                Self(self.0.query_param_missing("vpc"))
            }
        }
    }

    pub struct VpcSubnetListNetworkInterfacesThen(::httpmock::Then);
    impl VpcSubnetListNetworkInterfacesThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::InstanceNetworkInterfaceResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcListWhen(::httpmock::When);
    impl VpcListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpcs$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn limit<T>(self, value: T) -> Self
        where
            T: Into<Option<::std::num::NonZeroU32>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("limit", value.to_string()))
            } else {
                Self(self.0.query_param_missing("limit"))
            }
        }

        pub fn page_token<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a str>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("page_token", value.to_string()))
            } else {
                Self(self.0.query_param_missing("page_token"))
            }
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn sort_by<T>(self, value: T) -> Self
        where
            T: Into<Option<types::NameOrIdSortMode>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("sort_by", value.to_string()))
            } else {
                Self(self.0.query_param_missing("sort_by"))
            }
        }
    }

    pub struct VpcListThen(::httpmock::Then);
    impl VpcListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::VpcResultsPage) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcCreateWhen(::httpmock::When);
    impl VpcCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/vpcs$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn project(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("project", value.to_string()))
        }

        pub fn body(self, value: &types::VpcCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcCreateThen(::httpmock::Then);
    impl VpcCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::Vpc) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcViewWhen(::httpmock::When);
    impl VpcViewWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/vpcs/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/vpcs/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct VpcViewThen(::httpmock::Then);
    impl VpcViewThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Vpc) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcUpdateWhen(::httpmock::When);
    impl VpcUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/vpcs/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/vpcs/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }

        pub fn body(self, value: &types::VpcUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct VpcUpdateThen(::httpmock::Then);
    impl VpcUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::Vpc) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct VpcDeleteWhen(::httpmock::When);
    impl VpcDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/vpcs/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn vpc(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/vpcs/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn project<'a, T>(self, value: T) -> Self
        where
            T: Into<Option<&'a types::NameOrId>>,
        {
            if let Some(value) = value.into() {
                Self(self.0.query_param("project", value.to_string()))
            } else {
                Self(self.0.query_param_missing("project"))
            }
        }
    }

    pub struct VpcDeleteThen(::httpmock::Then);
    impl VpcDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct WebhookReceiverCreateWhen(::httpmock::When);
    impl WebhookReceiverCreateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/webhook-receivers$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn body(self, value: &types::WebhookCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct WebhookReceiverCreateThen(::httpmock::Then);
    impl WebhookReceiverCreateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::WebhookReceiver) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct WebhookReceiverUpdateWhen(::httpmock::When);
    impl WebhookReceiverUpdateWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::PUT)
                    .path_matches(regex::Regex::new("^/v1/webhook-receivers/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            let re = regex::Regex::new(&format!("^/v1/webhook-receivers/{}$", value.to_string()))
                .unwrap();
            Self(self.0.path_matches(re))
        }

        pub fn body(self, value: &types::WebhookReceiverUpdate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct WebhookReceiverUpdateThen(::httpmock::Then);
    impl WebhookReceiverUpdateThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct WebhookSecretsListWhen(::httpmock::When);
    impl WebhookSecretsListWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::GET)
                    .path_matches(regex::Regex::new("^/v1/webhook-secrets$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("receiver", value.to_string()))
        }
    }

    pub struct WebhookSecretsListThen(::httpmock::Then);
    impl WebhookSecretsListThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn ok(self, value: &types::WebhookSecrets) -> Self {
            Self(
                self.0
                    .status(200u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct WebhookSecretsAddWhen(::httpmock::When);
    impl WebhookSecretsAddWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::POST)
                    .path_matches(regex::Regex::new("^/v1/webhook-secrets$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn receiver(self, value: &types::NameOrId) -> Self {
            Self(self.0.query_param("receiver", value.to_string()))
        }

        pub fn body(self, value: &types::WebhookSecretCreate) -> Self {
            Self(self.0.json_body_obj(value))
        }
    }

    pub struct WebhookSecretsAddThen(::httpmock::Then);
    impl WebhookSecretsAddThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn created(self, value: &types::WebhookSecret) -> Self {
            Self(
                self.0
                    .status(201u16)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }

    pub struct WebhookSecretsDeleteWhen(::httpmock::When);
    impl WebhookSecretsDeleteWhen {
        pub fn new(inner: ::httpmock::When) -> Self {
            Self(
                inner
                    .method(::httpmock::Method::DELETE)
                    .path_matches(regex::Regex::new("^/v1/webhook-secrets/[^/]*$").unwrap()),
            )
        }

        pub fn into_inner(self) -> ::httpmock::When {
            self.0
        }

        pub fn secret_id(self, value: &::uuid::Uuid) -> Self {
            let re =
                regex::Regex::new(&format!("^/v1/webhook-secrets/{}$", value.to_string())).unwrap();
            Self(self.0.path_matches(re))
        }
    }

    pub struct WebhookSecretsDeleteThen(::httpmock::Then);
    impl WebhookSecretsDeleteThen {
        pub fn new(inner: ::httpmock::Then) -> Self {
            Self(inner)
        }

        pub fn into_inner(self) -> ::httpmock::Then {
            self.0
        }

        pub fn no_content(self) -> Self {
            Self(self.0.status(204u16))
        }

        pub fn client_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 4u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }

        pub fn server_error(self, status: u16, value: &types::Error) -> Self {
            assert_eq!(status / 100u16, 5u16);
            Self(
                self.0
                    .status(status)
                    .header("content-type", "application/json")
                    .json_body_obj(value),
            )
        }
    }
}

/// An extension trait for [`MockServer`](::httpmock::MockServer) that
/// adds a method for each operation. These are the equivalent of
/// type-checked [`mock()`](::httpmock::MockServer::mock) calls.
pub trait MockServerExt {
    fn device_auth_request<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DeviceAuthRequestWhen, operations::DeviceAuthRequestThen);
    fn device_auth_confirm<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DeviceAuthConfirmWhen, operations::DeviceAuthConfirmThen);
    fn device_access_token<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DeviceAccessTokenWhen, operations::DeviceAccessTokenThen);
    fn probe_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeListWhen, operations::ProbeListThen);
    fn probe_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeCreateWhen, operations::ProbeCreateThen);
    fn probe_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeViewWhen, operations::ProbeViewThen);
    fn probe_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeDeleteWhen, operations::ProbeDeleteThen);
    fn support_bundle_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleListWhen, operations::SupportBundleListThen);
    fn support_bundle_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleCreateWhen, operations::SupportBundleCreateThen);
    fn support_bundle_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleViewWhen, operations::SupportBundleViewThen);
    fn support_bundle_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleUpdateWhen, operations::SupportBundleUpdateThen);
    fn support_bundle_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleDeleteWhen, operations::SupportBundleDeleteThen);
    fn support_bundle_download<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleDownloadWhen, operations::SupportBundleDownloadThen);
    fn support_bundle_head<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleHeadWhen, operations::SupportBundleHeadThen);
    fn support_bundle_download_file<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SupportBundleDownloadFileWhen,
            operations::SupportBundleDownloadFileThen,
        );
    fn support_bundle_head_file<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleHeadFileWhen, operations::SupportBundleHeadFileThen);
    fn support_bundle_index<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleIndexWhen, operations::SupportBundleIndexThen);
    fn login_saml<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LoginSamlWhen, operations::LoginSamlThen);
    fn affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupListWhen, operations::AffinityGroupListThen);
    fn affinity_group_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupCreateWhen, operations::AffinityGroupCreateThen);
    fn affinity_group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupViewWhen, operations::AffinityGroupViewThen);
    fn affinity_group_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupUpdateWhen, operations::AffinityGroupUpdateThen);
    fn affinity_group_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupDeleteWhen, operations::AffinityGroupDeleteThen);
    fn affinity_group_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupMemberListWhen, operations::AffinityGroupMemberListThen);
    fn affinity_group_member_instance_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AffinityGroupMemberInstanceViewWhen,
            operations::AffinityGroupMemberInstanceViewThen,
        );
    fn affinity_group_member_instance_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AffinityGroupMemberInstanceAddWhen,
            operations::AffinityGroupMemberInstanceAddThen,
        );
    fn affinity_group_member_instance_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AffinityGroupMemberInstanceDeleteWhen,
            operations::AffinityGroupMemberInstanceDeleteThen,
        );
    fn alert_class_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertClassListWhen, operations::AlertClassListThen);
    fn alert_receiver_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverListWhen, operations::AlertReceiverListThen);
    fn alert_receiver_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverViewWhen, operations::AlertReceiverViewThen);
    fn alert_receiver_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverDeleteWhen, operations::AlertReceiverDeleteThen);
    fn alert_delivery_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertDeliveryListWhen, operations::AlertDeliveryListThen);
    fn alert_receiver_probe<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverProbeWhen, operations::AlertReceiverProbeThen);
    fn alert_receiver_subscription_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AlertReceiverSubscriptionAddWhen,
            operations::AlertReceiverSubscriptionAddThen,
        );
    fn alert_receiver_subscription_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AlertReceiverSubscriptionRemoveWhen,
            operations::AlertReceiverSubscriptionRemoveThen,
        );
    fn alert_delivery_resend<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertDeliveryResendWhen, operations::AlertDeliveryResendThen);
    fn anti_affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupListWhen, operations::AntiAffinityGroupListThen);
    fn anti_affinity_group_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupCreateWhen, operations::AntiAffinityGroupCreateThen);
    fn anti_affinity_group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupViewWhen, operations::AntiAffinityGroupViewThen);
    fn anti_affinity_group_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupUpdateWhen, operations::AntiAffinityGroupUpdateThen);
    fn anti_affinity_group_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupDeleteWhen, operations::AntiAffinityGroupDeleteThen);
    fn anti_affinity_group_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberListWhen,
            operations::AntiAffinityGroupMemberListThen,
        );
    fn anti_affinity_group_member_instance_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberInstanceViewWhen,
            operations::AntiAffinityGroupMemberInstanceViewThen,
        );
    fn anti_affinity_group_member_instance_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberInstanceAddWhen,
            operations::AntiAffinityGroupMemberInstanceAddThen,
        );
    fn anti_affinity_group_member_instance_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberInstanceDeleteWhen,
            operations::AntiAffinityGroupMemberInstanceDeleteThen,
        );
    fn auth_settings_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AuthSettingsViewWhen, operations::AuthSettingsViewThen);
    fn auth_settings_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AuthSettingsUpdateWhen, operations::AuthSettingsUpdateThen);
    fn certificate_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateListWhen, operations::CertificateListThen);
    fn certificate_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateCreateWhen, operations::CertificateCreateThen);
    fn certificate_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateViewWhen, operations::CertificateViewThen);
    fn certificate_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateDeleteWhen, operations::CertificateDeleteThen);
    fn disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskListWhen, operations::DiskListThen);
    fn disk_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskCreateWhen, operations::DiskCreateThen);
    fn disk_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskViewWhen, operations::DiskViewThen);
    fn disk_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskDeleteWhen, operations::DiskDeleteThen);
    fn disk_bulk_write_import<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskBulkWriteImportWhen, operations::DiskBulkWriteImportThen);
    fn disk_bulk_write_import_start<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::DiskBulkWriteImportStartWhen,
            operations::DiskBulkWriteImportStartThen,
        );
    fn disk_bulk_write_import_stop<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskBulkWriteImportStopWhen, operations::DiskBulkWriteImportStopThen);
    fn disk_finalize_import<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskFinalizeImportWhen, operations::DiskFinalizeImportThen);
    fn external_subnet_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetListWhen, operations::ExternalSubnetListThen);
    fn external_subnet_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetCreateWhen, operations::ExternalSubnetCreateThen);
    fn external_subnet_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetViewWhen, operations::ExternalSubnetViewThen);
    fn external_subnet_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetUpdateWhen, operations::ExternalSubnetUpdateThen);
    fn external_subnet_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetDeleteWhen, operations::ExternalSubnetDeleteThen);
    fn external_subnet_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetAttachWhen, operations::ExternalSubnetAttachThen);
    fn external_subnet_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetDetachWhen, operations::ExternalSubnetDetachThen);
    fn floating_ip_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpListWhen, operations::FloatingIpListThen);
    fn floating_ip_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpCreateWhen, operations::FloatingIpCreateThen);
    fn floating_ip_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpViewWhen, operations::FloatingIpViewThen);
    fn floating_ip_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpUpdateWhen, operations::FloatingIpUpdateThen);
    fn floating_ip_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpDeleteWhen, operations::FloatingIpDeleteThen);
    fn floating_ip_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpAttachWhen, operations::FloatingIpAttachThen);
    fn floating_ip_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpDetachWhen, operations::FloatingIpDetachThen);
    fn group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::GroupListWhen, operations::GroupListThen);
    fn group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::GroupViewWhen, operations::GroupViewThen);
    fn image_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageListWhen, operations::ImageListThen);
    fn image_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageCreateWhen, operations::ImageCreateThen);
    fn image_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageViewWhen, operations::ImageViewThen);
    fn image_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageDeleteWhen, operations::ImageDeleteThen);
    fn image_demote<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageDemoteWhen, operations::ImageDemoteThen);
    fn image_promote<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImagePromoteWhen, operations::ImagePromoteThen);
    fn instance_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceListWhen, operations::InstanceListThen);
    fn instance_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceCreateWhen, operations::InstanceCreateThen);
    fn instance_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceViewWhen, operations::InstanceViewThen);
    fn instance_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceUpdateWhen, operations::InstanceUpdateThen);
    fn instance_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDeleteWhen, operations::InstanceDeleteThen);
    fn instance_affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceAffinityGroupListWhen,
            operations::InstanceAffinityGroupListThen,
        );
    fn instance_anti_affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceAntiAffinityGroupListWhen,
            operations::InstanceAntiAffinityGroupListThen,
        );
    fn instance_disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDiskListWhen, operations::InstanceDiskListThen);
    fn instance_disk_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDiskAttachWhen, operations::InstanceDiskAttachThen);
    fn instance_disk_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDiskDetachWhen, operations::InstanceDiskDetachThen);
    fn instance_external_ip_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceExternalIpListWhen, operations::InstanceExternalIpListThen);
    fn instance_ephemeral_ip_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceEphemeralIpAttachWhen,
            operations::InstanceEphemeralIpAttachThen,
        );
    fn instance_ephemeral_ip_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceEphemeralIpDetachWhen,
            operations::InstanceEphemeralIpDetachThen,
        );
    fn instance_external_subnet_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceExternalSubnetListWhen,
            operations::InstanceExternalSubnetListThen,
        );
    fn instance_multicast_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceMulticastGroupListWhen,
            operations::InstanceMulticastGroupListThen,
        );
    fn instance_multicast_group_join<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceMulticastGroupJoinWhen,
            operations::InstanceMulticastGroupJoinThen,
        );
    fn instance_multicast_group_leave<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceMulticastGroupLeaveWhen,
            operations::InstanceMulticastGroupLeaveThen,
        );
    fn instance_reboot<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceRebootWhen, operations::InstanceRebootThen);
    fn instance_serial_console<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceSerialConsoleWhen, operations::InstanceSerialConsoleThen);
    fn instance_serial_console_stream<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceSerialConsoleStreamWhen,
            operations::InstanceSerialConsoleStreamThen,
        );
    fn instance_ssh_public_key_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceSshPublicKeyListWhen,
            operations::InstanceSshPublicKeyListThen,
        );
    fn instance_start<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceStartWhen, operations::InstanceStartThen);
    fn instance_stop<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceStopWhen, operations::InstanceStopThen);
    fn internet_gateway_ip_address_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpAddressListWhen,
            operations::InternetGatewayIpAddressListThen,
        );
    fn internet_gateway_ip_address_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpAddressCreateWhen,
            operations::InternetGatewayIpAddressCreateThen,
        );
    fn internet_gateway_ip_address_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpAddressDeleteWhen,
            operations::InternetGatewayIpAddressDeleteThen,
        );
    fn internet_gateway_ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpPoolListWhen,
            operations::InternetGatewayIpPoolListThen,
        );
    fn internet_gateway_ip_pool_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpPoolCreateWhen,
            operations::InternetGatewayIpPoolCreateThen,
        );
    fn internet_gateway_ip_pool_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpPoolDeleteWhen,
            operations::InternetGatewayIpPoolDeleteThen,
        );
    fn internet_gateway_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayListWhen, operations::InternetGatewayListThen);
    fn internet_gateway_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayCreateWhen, operations::InternetGatewayCreateThen);
    fn internet_gateway_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayViewWhen, operations::InternetGatewayViewThen);
    fn internet_gateway_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayDeleteWhen, operations::InternetGatewayDeleteThen);
    fn ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::IpPoolListWhen, operations::IpPoolListThen);
    fn ip_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::IpPoolViewWhen, operations::IpPoolViewThen);
    fn login_local<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LoginLocalWhen, operations::LoginLocalThen);
    fn logout<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LogoutWhen, operations::LogoutThen);
    fn current_user_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserViewWhen, operations::CurrentUserViewThen);
    fn current_user_access_token_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::CurrentUserAccessTokenListWhen,
            operations::CurrentUserAccessTokenListThen,
        );
    fn current_user_access_token_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::CurrentUserAccessTokenDeleteWhen,
            operations::CurrentUserAccessTokenDeleteThen,
        );
    fn current_user_groups<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserGroupsWhen, operations::CurrentUserGroupsThen);
    fn current_user_ssh_key_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyListWhen, operations::CurrentUserSshKeyListThen);
    fn current_user_ssh_key_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyCreateWhen, operations::CurrentUserSshKeyCreateThen);
    fn current_user_ssh_key_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyViewWhen, operations::CurrentUserSshKeyViewThen);
    fn current_user_ssh_key_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyDeleteWhen, operations::CurrentUserSshKeyDeleteThen);
    fn silo_metric<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloMetricWhen, operations::SiloMetricThen);
    fn multicast_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::MulticastGroupListWhen, operations::MulticastGroupListThen);
    fn multicast_group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::MulticastGroupViewWhen, operations::MulticastGroupViewThen);
    fn multicast_group_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::MulticastGroupMemberListWhen,
            operations::MulticastGroupMemberListThen,
        );
    fn instance_network_interface_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceListWhen,
            operations::InstanceNetworkInterfaceListThen,
        );
    fn instance_network_interface_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceCreateWhen,
            operations::InstanceNetworkInterfaceCreateThen,
        );
    fn instance_network_interface_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceViewWhen,
            operations::InstanceNetworkInterfaceViewThen,
        );
    fn instance_network_interface_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceUpdateWhen,
            operations::InstanceNetworkInterfaceUpdateThen,
        );
    fn instance_network_interface_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceDeleteWhen,
            operations::InstanceNetworkInterfaceDeleteThen,
        );
    fn ping<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PingWhen, operations::PingThen);
    fn policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PolicyViewWhen, operations::PolicyViewThen);
    fn policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PolicyUpdateWhen, operations::PolicyUpdateThen);
    fn project_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectListWhen, operations::ProjectListThen);
    fn project_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectCreateWhen, operations::ProjectCreateThen);
    fn project_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectViewWhen, operations::ProjectViewThen);
    fn project_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectUpdateWhen, operations::ProjectUpdateThen);
    fn project_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectDeleteWhen, operations::ProjectDeleteThen);
    fn project_policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectPolicyViewWhen, operations::ProjectPolicyViewThen);
    fn project_policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectPolicyUpdateWhen, operations::ProjectPolicyUpdateThen);
    fn snapshot_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotListWhen, operations::SnapshotListThen);
    fn snapshot_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotCreateWhen, operations::SnapshotCreateThen);
    fn snapshot_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotViewWhen, operations::SnapshotViewThen);
    fn snapshot_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotDeleteWhen, operations::SnapshotDeleteThen);
    fn subnet_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SubnetPoolListWhen, operations::SubnetPoolListThen);
    fn subnet_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SubnetPoolViewWhen, operations::SubnetPoolViewThen);
    fn audit_log_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AuditLogListWhen, operations::AuditLogListThen);
    fn physical_disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PhysicalDiskListWhen, operations::PhysicalDiskListThen);
    fn physical_disk_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PhysicalDiskViewWhen, operations::PhysicalDiskViewThen);
    fn networking_switch_port_lldp_neighbors<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortLldpNeighborsWhen,
            operations::NetworkingSwitchPortLldpNeighborsThen,
        );
    fn rack_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackListWhen, operations::RackListThen);
    fn rack_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackViewWhen, operations::RackViewThen);
    fn rack_membership_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackMembershipStatusWhen, operations::RackMembershipStatusThen);
    fn rack_membership_abort<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackMembershipAbortWhen, operations::RackMembershipAbortThen);
    fn rack_membership_add_sleds<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackMembershipAddSledsWhen, operations::RackMembershipAddSledsThen);
    fn sled_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledListWhen, operations::SledListThen);
    fn sled_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledAddWhen, operations::SledAddThen);
    fn sled_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledViewWhen, operations::SledViewThen);
    fn sled_physical_disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledPhysicalDiskListWhen, operations::SledPhysicalDiskListThen);
    fn sled_instance_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledInstanceListWhen, operations::SledInstanceListThen);
    fn sled_set_provision_policy<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledSetProvisionPolicyWhen, operations::SledSetProvisionPolicyThen);
    fn sled_list_uninitialized<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledListUninitializedWhen, operations::SledListUninitializedThen);
    fn networking_switch_port_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortListWhen,
            operations::NetworkingSwitchPortListThen,
        );
    fn networking_switch_port_lldp_config_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortLldpConfigViewWhen,
            operations::NetworkingSwitchPortLldpConfigViewThen,
        );
    fn networking_switch_port_lldp_config_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortLldpConfigUpdateWhen,
            operations::NetworkingSwitchPortLldpConfigUpdateThen,
        );
    fn networking_switch_port_apply_settings<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortApplySettingsWhen,
            operations::NetworkingSwitchPortApplySettingsThen,
        );
    fn networking_switch_port_clear_settings<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortClearSettingsWhen,
            operations::NetworkingSwitchPortClearSettingsThen,
        );
    fn networking_switch_port_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortStatusWhen,
            operations::NetworkingSwitchPortStatusThen,
        );
    fn switch_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SwitchListWhen, operations::SwitchListThen);
    fn switch_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SwitchViewWhen, operations::SwitchViewThen);
    fn silo_identity_provider_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SiloIdentityProviderListWhen,
            operations::SiloIdentityProviderListThen,
        );
    fn local_idp_user_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LocalIdpUserCreateWhen, operations::LocalIdpUserCreateThen);
    fn local_idp_user_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LocalIdpUserDeleteWhen, operations::LocalIdpUserDeleteThen);
    fn local_idp_user_set_password<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LocalIdpUserSetPasswordWhen, operations::LocalIdpUserSetPasswordThen);
    fn saml_identity_provider_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SamlIdentityProviderCreateWhen,
            operations::SamlIdentityProviderCreateThen,
        );
    fn saml_identity_provider_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SamlIdentityProviderViewWhen,
            operations::SamlIdentityProviderViewThen,
        );
    fn system_ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolListWhen, operations::SystemIpPoolListThen);
    fn system_ip_pool_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolCreateWhen, operations::SystemIpPoolCreateThen);
    fn system_ip_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolViewWhen, operations::SystemIpPoolViewThen);
    fn system_ip_pool_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolUpdateWhen, operations::SystemIpPoolUpdateThen);
    fn system_ip_pool_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolDeleteWhen, operations::SystemIpPoolDeleteThen);
    fn system_ip_pool_range_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolRangeListWhen, operations::SystemIpPoolRangeListThen);
    fn system_ip_pool_range_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolRangeAddWhen, operations::SystemIpPoolRangeAddThen);
    fn system_ip_pool_range_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolRangeRemoveWhen, operations::SystemIpPoolRangeRemoveThen);
    fn system_ip_pool_silo_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloListWhen, operations::SystemIpPoolSiloListThen);
    fn system_ip_pool_silo_link<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloLinkWhen, operations::SystemIpPoolSiloLinkThen);
    fn system_ip_pool_silo_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloUpdateWhen, operations::SystemIpPoolSiloUpdateThen);
    fn system_ip_pool_silo_unlink<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloUnlinkWhen, operations::SystemIpPoolSiloUnlinkThen);
    fn system_ip_pool_utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolUtilizationViewWhen,
            operations::SystemIpPoolUtilizationViewThen,
        );
    fn system_ip_pool_service_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolServiceViewWhen, operations::SystemIpPoolServiceViewThen);
    fn system_ip_pool_service_range_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolServiceRangeListWhen,
            operations::SystemIpPoolServiceRangeListThen,
        );
    fn system_ip_pool_service_range_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolServiceRangeAddWhen,
            operations::SystemIpPoolServiceRangeAddThen,
        );
    fn system_ip_pool_service_range_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolServiceRangeRemoveWhen,
            operations::SystemIpPoolServiceRangeRemoveThen,
        );
    fn system_metric<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemMetricWhen, operations::SystemMetricThen);
    fn networking_address_lot_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotListWhen,
            operations::NetworkingAddressLotListThen,
        );
    fn networking_address_lot_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotCreateWhen,
            operations::NetworkingAddressLotCreateThen,
        );
    fn networking_address_lot_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotViewWhen,
            operations::NetworkingAddressLotViewThen,
        );
    fn networking_address_lot_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotDeleteWhen,
            operations::NetworkingAddressLotDeleteThen,
        );
    fn networking_address_lot_block_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotBlockListWhen,
            operations::NetworkingAddressLotBlockListThen,
        );
    fn networking_allow_list_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingAllowListViewWhen, operations::NetworkingAllowListViewThen);
    fn networking_allow_list_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAllowListUpdateWhen,
            operations::NetworkingAllowListUpdateThen,
        );
    fn networking_bfd_disable<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBfdDisableWhen, operations::NetworkingBfdDisableThen);
    fn networking_bfd_enable<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBfdEnableWhen, operations::NetworkingBfdEnableThen);
    fn networking_bfd_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBfdStatusWhen, operations::NetworkingBfdStatusThen);
    fn networking_bgp_config_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpConfigListWhen, operations::NetworkingBgpConfigListThen);
    fn networking_bgp_config_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpConfigCreateWhen,
            operations::NetworkingBgpConfigCreateThen,
        );
    fn networking_bgp_config_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpConfigDeleteWhen,
            operations::NetworkingBgpConfigDeleteThen,
        );
    fn networking_bgp_announce_set_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnounceSetListWhen,
            operations::NetworkingBgpAnnounceSetListThen,
        );
    fn networking_bgp_announce_set_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnounceSetUpdateWhen,
            operations::NetworkingBgpAnnounceSetUpdateThen,
        );
    fn networking_bgp_announce_set_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnounceSetDeleteWhen,
            operations::NetworkingBgpAnnounceSetDeleteThen,
        );
    fn networking_bgp_announcement_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnouncementListWhen,
            operations::NetworkingBgpAnnouncementListThen,
        );
    fn networking_bgp_exported<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpExportedWhen, operations::NetworkingBgpExportedThen);
    fn networking_bgp_imported<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpImportedWhen, operations::NetworkingBgpImportedThen);
    fn networking_bgp_message_history<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpMessageHistoryWhen,
            operations::NetworkingBgpMessageHistoryThen,
        );
    fn networking_bgp_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpStatusWhen, operations::NetworkingBgpStatusThen);
    fn networking_inbound_icmp_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingInboundIcmpViewWhen,
            operations::NetworkingInboundIcmpViewThen,
        );
    fn networking_inbound_icmp_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingInboundIcmpUpdateWhen,
            operations::NetworkingInboundIcmpUpdateThen,
        );
    fn networking_loopback_address_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingLoopbackAddressListWhen,
            operations::NetworkingLoopbackAddressListThen,
        );
    fn networking_loopback_address_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingLoopbackAddressCreateWhen,
            operations::NetworkingLoopbackAddressCreateThen,
        );
    fn networking_loopback_address_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingLoopbackAddressDeleteWhen,
            operations::NetworkingLoopbackAddressDeleteThen,
        );
    fn networking_switch_port_settings_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsListWhen,
            operations::NetworkingSwitchPortSettingsListThen,
        );
    fn networking_switch_port_settings_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsCreateWhen,
            operations::NetworkingSwitchPortSettingsCreateThen,
        );
    fn networking_switch_port_settings_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsDeleteWhen,
            operations::NetworkingSwitchPortSettingsDeleteThen,
        );
    fn networking_switch_port_settings_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsViewWhen,
            operations::NetworkingSwitchPortSettingsViewThen,
        );
    fn system_policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemPolicyViewWhen, operations::SystemPolicyViewThen);
    fn system_policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemPolicyUpdateWhen, operations::SystemPolicyUpdateThen);
    fn scim_token_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenListWhen, operations::ScimTokenListThen);
    fn scim_token_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenCreateWhen, operations::ScimTokenCreateThen);
    fn scim_token_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenViewWhen, operations::ScimTokenViewThen);
    fn scim_token_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenDeleteWhen, operations::ScimTokenDeleteThen);
    fn system_quotas_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemQuotasListWhen, operations::SystemQuotasListThen);
    fn silo_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloListWhen, operations::SiloListThen);
    fn silo_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloCreateWhen, operations::SiloCreateThen);
    fn silo_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloViewWhen, operations::SiloViewThen);
    fn silo_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloDeleteWhen, operations::SiloDeleteThen);
    fn silo_ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloIpPoolListWhen, operations::SiloIpPoolListThen);
    fn silo_policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloPolicyViewWhen, operations::SiloPolicyViewThen);
    fn silo_policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloPolicyUpdateWhen, operations::SiloPolicyUpdateThen);
    fn silo_quotas_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloQuotasViewWhen, operations::SiloQuotasViewThen);
    fn silo_quotas_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloQuotasUpdateWhen, operations::SiloQuotasUpdateThen);
    fn silo_subnet_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloSubnetPoolListWhen, operations::SiloSubnetPoolListThen);
    fn system_subnet_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolListWhen, operations::SystemSubnetPoolListThen);
    fn system_subnet_pool_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolCreateWhen, operations::SystemSubnetPoolCreateThen);
    fn system_subnet_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolViewWhen, operations::SystemSubnetPoolViewThen);
    fn system_subnet_pool_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolUpdateWhen, operations::SystemSubnetPoolUpdateThen);
    fn system_subnet_pool_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolDeleteWhen, operations::SystemSubnetPoolDeleteThen);
    fn system_subnet_pool_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolMemberListWhen,
            operations::SystemSubnetPoolMemberListThen,
        );
    fn system_subnet_pool_member_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolMemberAddWhen,
            operations::SystemSubnetPoolMemberAddThen,
        );
    fn system_subnet_pool_member_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolMemberRemoveWhen,
            operations::SystemSubnetPoolMemberRemoveThen,
        );
    fn system_subnet_pool_silo_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloListWhen,
            operations::SystemSubnetPoolSiloListThen,
        );
    fn system_subnet_pool_silo_link<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloLinkWhen,
            operations::SystemSubnetPoolSiloLinkThen,
        );
    fn system_subnet_pool_silo_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloUpdateWhen,
            operations::SystemSubnetPoolSiloUpdateThen,
        );
    fn system_subnet_pool_silo_unlink<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloUnlinkWhen,
            operations::SystemSubnetPoolSiloUnlinkThen,
        );
    fn system_subnet_pool_utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolUtilizationViewWhen,
            operations::SystemSubnetPoolUtilizationViewThen,
        );
    fn system_timeseries_query<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemTimeseriesQueryWhen, operations::SystemTimeseriesQueryThen);
    fn system_timeseries_schema_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemTimeseriesSchemaListWhen,
            operations::SystemTimeseriesSchemaListThen,
        );
    fn system_update_repository_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateRepositoryListWhen,
            operations::SystemUpdateRepositoryListThen,
        );
    fn system_update_repository_upload<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateRepositoryUploadWhen,
            operations::SystemUpdateRepositoryUploadThen,
        );
    fn system_update_repository_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateRepositoryViewWhen,
            operations::SystemUpdateRepositoryViewThen,
        );
    fn system_update_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemUpdateStatusWhen, operations::SystemUpdateStatusThen);
    fn target_release_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::TargetReleaseUpdateWhen, operations::TargetReleaseUpdateThen);
    fn system_update_trust_root_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootListWhen,
            operations::SystemUpdateTrustRootListThen,
        );
    fn system_update_trust_root_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootCreateWhen,
            operations::SystemUpdateTrustRootCreateThen,
        );
    fn system_update_trust_root_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootViewWhen,
            operations::SystemUpdateTrustRootViewThen,
        );
    fn system_update_trust_root_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootDeleteWhen,
            operations::SystemUpdateTrustRootDeleteThen,
        );
    fn silo_user_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUserListWhen, operations::SiloUserListThen);
    fn silo_user_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUserViewWhen, operations::SiloUserViewThen);
    fn user_builtin_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserBuiltinListWhen, operations::UserBuiltinListThen);
    fn user_builtin_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserBuiltinViewWhen, operations::UserBuiltinViewThen);
    fn silo_utilization_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUtilizationListWhen, operations::SiloUtilizationListThen);
    fn silo_utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUtilizationViewWhen, operations::SiloUtilizationViewThen);
    fn timeseries_query<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::TimeseriesQueryWhen, operations::TimeseriesQueryThen);
    fn user_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserListWhen, operations::UserListThen);
    fn user_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserViewWhen, operations::UserViewThen);
    fn user_token_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserTokenListWhen, operations::UserTokenListThen);
    fn user_logout<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserLogoutWhen, operations::UserLogoutThen);
    fn user_session_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserSessionListWhen, operations::UserSessionListThen);
    fn utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UtilizationViewWhen, operations::UtilizationViewThen);
    fn vpc_firewall_rules_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcFirewallRulesViewWhen, operations::VpcFirewallRulesViewThen);
    fn vpc_firewall_rules_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcFirewallRulesUpdateWhen, operations::VpcFirewallRulesUpdateThen);
    fn vpc_router_route_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteListWhen, operations::VpcRouterRouteListThen);
    fn vpc_router_route_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteCreateWhen, operations::VpcRouterRouteCreateThen);
    fn vpc_router_route_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteViewWhen, operations::VpcRouterRouteViewThen);
    fn vpc_router_route_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteUpdateWhen, operations::VpcRouterRouteUpdateThen);
    fn vpc_router_route_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteDeleteWhen, operations::VpcRouterRouteDeleteThen);
    fn vpc_router_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterListWhen, operations::VpcRouterListThen);
    fn vpc_router_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterCreateWhen, operations::VpcRouterCreateThen);
    fn vpc_router_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterViewWhen, operations::VpcRouterViewThen);
    fn vpc_router_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterUpdateWhen, operations::VpcRouterUpdateThen);
    fn vpc_router_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterDeleteWhen, operations::VpcRouterDeleteThen);
    fn vpc_subnet_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetListWhen, operations::VpcSubnetListThen);
    fn vpc_subnet_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetCreateWhen, operations::VpcSubnetCreateThen);
    fn vpc_subnet_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetViewWhen, operations::VpcSubnetViewThen);
    fn vpc_subnet_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetUpdateWhen, operations::VpcSubnetUpdateThen);
    fn vpc_subnet_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetDeleteWhen, operations::VpcSubnetDeleteThen);
    fn vpc_subnet_list_network_interfaces<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::VpcSubnetListNetworkInterfacesWhen,
            operations::VpcSubnetListNetworkInterfacesThen,
        );
    fn vpc_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcListWhen, operations::VpcListThen);
    fn vpc_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcCreateWhen, operations::VpcCreateThen);
    fn vpc_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcViewWhen, operations::VpcViewThen);
    fn vpc_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcUpdateWhen, operations::VpcUpdateThen);
    fn vpc_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcDeleteWhen, operations::VpcDeleteThen);
    fn webhook_receiver_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookReceiverCreateWhen, operations::WebhookReceiverCreateThen);
    fn webhook_receiver_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookReceiverUpdateWhen, operations::WebhookReceiverUpdateThen);
    fn webhook_secrets_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookSecretsListWhen, operations::WebhookSecretsListThen);
    fn webhook_secrets_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookSecretsAddWhen, operations::WebhookSecretsAddThen);
    fn webhook_secrets_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookSecretsDeleteWhen, operations::WebhookSecretsDeleteThen);
}

impl MockServerExt for ::httpmock::MockServer {
    fn device_auth_request<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DeviceAuthRequestWhen, operations::DeviceAuthRequestThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DeviceAuthRequestWhen::new(when),
                operations::DeviceAuthRequestThen::new(then),
            )
        })
    }

    fn device_auth_confirm<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DeviceAuthConfirmWhen, operations::DeviceAuthConfirmThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DeviceAuthConfirmWhen::new(when),
                operations::DeviceAuthConfirmThen::new(then),
            )
        })
    }

    fn device_access_token<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DeviceAccessTokenWhen, operations::DeviceAccessTokenThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DeviceAccessTokenWhen::new(when),
                operations::DeviceAccessTokenThen::new(then),
            )
        })
    }

    fn probe_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeListWhen, operations::ProbeListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProbeListWhen::new(when),
                operations::ProbeListThen::new(then),
            )
        })
    }

    fn probe_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeCreateWhen, operations::ProbeCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProbeCreateWhen::new(when),
                operations::ProbeCreateThen::new(then),
            )
        })
    }

    fn probe_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeViewWhen, operations::ProbeViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProbeViewWhen::new(when),
                operations::ProbeViewThen::new(then),
            )
        })
    }

    fn probe_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProbeDeleteWhen, operations::ProbeDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProbeDeleteWhen::new(when),
                operations::ProbeDeleteThen::new(then),
            )
        })
    }

    fn support_bundle_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleListWhen, operations::SupportBundleListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleListWhen::new(when),
                operations::SupportBundleListThen::new(then),
            )
        })
    }

    fn support_bundle_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleCreateWhen, operations::SupportBundleCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleCreateWhen::new(when),
                operations::SupportBundleCreateThen::new(then),
            )
        })
    }

    fn support_bundle_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleViewWhen, operations::SupportBundleViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleViewWhen::new(when),
                operations::SupportBundleViewThen::new(then),
            )
        })
    }

    fn support_bundle_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleUpdateWhen, operations::SupportBundleUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleUpdateWhen::new(when),
                operations::SupportBundleUpdateThen::new(then),
            )
        })
    }

    fn support_bundle_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleDeleteWhen, operations::SupportBundleDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleDeleteWhen::new(when),
                operations::SupportBundleDeleteThen::new(then),
            )
        })
    }

    fn support_bundle_download<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleDownloadWhen, operations::SupportBundleDownloadThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleDownloadWhen::new(when),
                operations::SupportBundleDownloadThen::new(then),
            )
        })
    }

    fn support_bundle_head<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleHeadWhen, operations::SupportBundleHeadThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleHeadWhen::new(when),
                operations::SupportBundleHeadThen::new(then),
            )
        })
    }

    fn support_bundle_download_file<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SupportBundleDownloadFileWhen,
            operations::SupportBundleDownloadFileThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleDownloadFileWhen::new(when),
                operations::SupportBundleDownloadFileThen::new(then),
            )
        })
    }

    fn support_bundle_head_file<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleHeadFileWhen, operations::SupportBundleHeadFileThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleHeadFileWhen::new(when),
                operations::SupportBundleHeadFileThen::new(then),
            )
        })
    }

    fn support_bundle_index<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SupportBundleIndexWhen, operations::SupportBundleIndexThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SupportBundleIndexWhen::new(when),
                operations::SupportBundleIndexThen::new(then),
            )
        })
    }

    fn login_saml<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LoginSamlWhen, operations::LoginSamlThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::LoginSamlWhen::new(when),
                operations::LoginSamlThen::new(then),
            )
        })
    }

    fn affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupListWhen, operations::AffinityGroupListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupListWhen::new(when),
                operations::AffinityGroupListThen::new(then),
            )
        })
    }

    fn affinity_group_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupCreateWhen, operations::AffinityGroupCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupCreateWhen::new(when),
                operations::AffinityGroupCreateThen::new(then),
            )
        })
    }

    fn affinity_group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupViewWhen, operations::AffinityGroupViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupViewWhen::new(when),
                operations::AffinityGroupViewThen::new(then),
            )
        })
    }

    fn affinity_group_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupUpdateWhen, operations::AffinityGroupUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupUpdateWhen::new(when),
                operations::AffinityGroupUpdateThen::new(then),
            )
        })
    }

    fn affinity_group_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupDeleteWhen, operations::AffinityGroupDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupDeleteWhen::new(when),
                operations::AffinityGroupDeleteThen::new(then),
            )
        })
    }

    fn affinity_group_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AffinityGroupMemberListWhen, operations::AffinityGroupMemberListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupMemberListWhen::new(when),
                operations::AffinityGroupMemberListThen::new(then),
            )
        })
    }

    fn affinity_group_member_instance_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AffinityGroupMemberInstanceViewWhen,
            operations::AffinityGroupMemberInstanceViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupMemberInstanceViewWhen::new(when),
                operations::AffinityGroupMemberInstanceViewThen::new(then),
            )
        })
    }

    fn affinity_group_member_instance_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AffinityGroupMemberInstanceAddWhen,
            operations::AffinityGroupMemberInstanceAddThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupMemberInstanceAddWhen::new(when),
                operations::AffinityGroupMemberInstanceAddThen::new(then),
            )
        })
    }

    fn affinity_group_member_instance_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AffinityGroupMemberInstanceDeleteWhen,
            operations::AffinityGroupMemberInstanceDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AffinityGroupMemberInstanceDeleteWhen::new(when),
                operations::AffinityGroupMemberInstanceDeleteThen::new(then),
            )
        })
    }

    fn alert_class_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertClassListWhen, operations::AlertClassListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertClassListWhen::new(when),
                operations::AlertClassListThen::new(then),
            )
        })
    }

    fn alert_receiver_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverListWhen, operations::AlertReceiverListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertReceiverListWhen::new(when),
                operations::AlertReceiverListThen::new(then),
            )
        })
    }

    fn alert_receiver_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverViewWhen, operations::AlertReceiverViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertReceiverViewWhen::new(when),
                operations::AlertReceiverViewThen::new(then),
            )
        })
    }

    fn alert_receiver_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverDeleteWhen, operations::AlertReceiverDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertReceiverDeleteWhen::new(when),
                operations::AlertReceiverDeleteThen::new(then),
            )
        })
    }

    fn alert_delivery_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertDeliveryListWhen, operations::AlertDeliveryListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertDeliveryListWhen::new(when),
                operations::AlertDeliveryListThen::new(then),
            )
        })
    }

    fn alert_receiver_probe<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertReceiverProbeWhen, operations::AlertReceiverProbeThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertReceiverProbeWhen::new(when),
                operations::AlertReceiverProbeThen::new(then),
            )
        })
    }

    fn alert_receiver_subscription_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AlertReceiverSubscriptionAddWhen,
            operations::AlertReceiverSubscriptionAddThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertReceiverSubscriptionAddWhen::new(when),
                operations::AlertReceiverSubscriptionAddThen::new(then),
            )
        })
    }

    fn alert_receiver_subscription_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AlertReceiverSubscriptionRemoveWhen,
            operations::AlertReceiverSubscriptionRemoveThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertReceiverSubscriptionRemoveWhen::new(when),
                operations::AlertReceiverSubscriptionRemoveThen::new(then),
            )
        })
    }

    fn alert_delivery_resend<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AlertDeliveryResendWhen, operations::AlertDeliveryResendThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AlertDeliveryResendWhen::new(when),
                operations::AlertDeliveryResendThen::new(then),
            )
        })
    }

    fn anti_affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupListWhen, operations::AntiAffinityGroupListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupListWhen::new(when),
                operations::AntiAffinityGroupListThen::new(then),
            )
        })
    }

    fn anti_affinity_group_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupCreateWhen, operations::AntiAffinityGroupCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupCreateWhen::new(when),
                operations::AntiAffinityGroupCreateThen::new(then),
            )
        })
    }

    fn anti_affinity_group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupViewWhen, operations::AntiAffinityGroupViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupViewWhen::new(when),
                operations::AntiAffinityGroupViewThen::new(then),
            )
        })
    }

    fn anti_affinity_group_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupUpdateWhen, operations::AntiAffinityGroupUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupUpdateWhen::new(when),
                operations::AntiAffinityGroupUpdateThen::new(then),
            )
        })
    }

    fn anti_affinity_group_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AntiAffinityGroupDeleteWhen, operations::AntiAffinityGroupDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupDeleteWhen::new(when),
                operations::AntiAffinityGroupDeleteThen::new(then),
            )
        })
    }

    fn anti_affinity_group_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberListWhen,
            operations::AntiAffinityGroupMemberListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupMemberListWhen::new(when),
                operations::AntiAffinityGroupMemberListThen::new(then),
            )
        })
    }

    fn anti_affinity_group_member_instance_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberInstanceViewWhen,
            operations::AntiAffinityGroupMemberInstanceViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupMemberInstanceViewWhen::new(when),
                operations::AntiAffinityGroupMemberInstanceViewThen::new(then),
            )
        })
    }

    fn anti_affinity_group_member_instance_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberInstanceAddWhen,
            operations::AntiAffinityGroupMemberInstanceAddThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupMemberInstanceAddWhen::new(when),
                operations::AntiAffinityGroupMemberInstanceAddThen::new(then),
            )
        })
    }

    fn anti_affinity_group_member_instance_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::AntiAffinityGroupMemberInstanceDeleteWhen,
            operations::AntiAffinityGroupMemberInstanceDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AntiAffinityGroupMemberInstanceDeleteWhen::new(when),
                operations::AntiAffinityGroupMemberInstanceDeleteThen::new(then),
            )
        })
    }

    fn auth_settings_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AuthSettingsViewWhen, operations::AuthSettingsViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AuthSettingsViewWhen::new(when),
                operations::AuthSettingsViewThen::new(then),
            )
        })
    }

    fn auth_settings_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AuthSettingsUpdateWhen, operations::AuthSettingsUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AuthSettingsUpdateWhen::new(when),
                operations::AuthSettingsUpdateThen::new(then),
            )
        })
    }

    fn certificate_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateListWhen, operations::CertificateListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CertificateListWhen::new(when),
                operations::CertificateListThen::new(then),
            )
        })
    }

    fn certificate_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateCreateWhen, operations::CertificateCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CertificateCreateWhen::new(when),
                operations::CertificateCreateThen::new(then),
            )
        })
    }

    fn certificate_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateViewWhen, operations::CertificateViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CertificateViewWhen::new(when),
                operations::CertificateViewThen::new(then),
            )
        })
    }

    fn certificate_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CertificateDeleteWhen, operations::CertificateDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CertificateDeleteWhen::new(when),
                operations::CertificateDeleteThen::new(then),
            )
        })
    }

    fn disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskListWhen, operations::DiskListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskListWhen::new(when),
                operations::DiskListThen::new(then),
            )
        })
    }

    fn disk_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskCreateWhen, operations::DiskCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskCreateWhen::new(when),
                operations::DiskCreateThen::new(then),
            )
        })
    }

    fn disk_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskViewWhen, operations::DiskViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskViewWhen::new(when),
                operations::DiskViewThen::new(then),
            )
        })
    }

    fn disk_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskDeleteWhen, operations::DiskDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskDeleteWhen::new(when),
                operations::DiskDeleteThen::new(then),
            )
        })
    }

    fn disk_bulk_write_import<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskBulkWriteImportWhen, operations::DiskBulkWriteImportThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskBulkWriteImportWhen::new(when),
                operations::DiskBulkWriteImportThen::new(then),
            )
        })
    }

    fn disk_bulk_write_import_start<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::DiskBulkWriteImportStartWhen,
            operations::DiskBulkWriteImportStartThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskBulkWriteImportStartWhen::new(when),
                operations::DiskBulkWriteImportStartThen::new(then),
            )
        })
    }

    fn disk_bulk_write_import_stop<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskBulkWriteImportStopWhen, operations::DiskBulkWriteImportStopThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskBulkWriteImportStopWhen::new(when),
                operations::DiskBulkWriteImportStopThen::new(then),
            )
        })
    }

    fn disk_finalize_import<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::DiskFinalizeImportWhen, operations::DiskFinalizeImportThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::DiskFinalizeImportWhen::new(when),
                operations::DiskFinalizeImportThen::new(then),
            )
        })
    }

    fn external_subnet_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetListWhen, operations::ExternalSubnetListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetListWhen::new(when),
                operations::ExternalSubnetListThen::new(then),
            )
        })
    }

    fn external_subnet_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetCreateWhen, operations::ExternalSubnetCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetCreateWhen::new(when),
                operations::ExternalSubnetCreateThen::new(then),
            )
        })
    }

    fn external_subnet_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetViewWhen, operations::ExternalSubnetViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetViewWhen::new(when),
                operations::ExternalSubnetViewThen::new(then),
            )
        })
    }

    fn external_subnet_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetUpdateWhen, operations::ExternalSubnetUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetUpdateWhen::new(when),
                operations::ExternalSubnetUpdateThen::new(then),
            )
        })
    }

    fn external_subnet_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetDeleteWhen, operations::ExternalSubnetDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetDeleteWhen::new(when),
                operations::ExternalSubnetDeleteThen::new(then),
            )
        })
    }

    fn external_subnet_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetAttachWhen, operations::ExternalSubnetAttachThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetAttachWhen::new(when),
                operations::ExternalSubnetAttachThen::new(then),
            )
        })
    }

    fn external_subnet_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ExternalSubnetDetachWhen, operations::ExternalSubnetDetachThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ExternalSubnetDetachWhen::new(when),
                operations::ExternalSubnetDetachThen::new(then),
            )
        })
    }

    fn floating_ip_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpListWhen, operations::FloatingIpListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpListWhen::new(when),
                operations::FloatingIpListThen::new(then),
            )
        })
    }

    fn floating_ip_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpCreateWhen, operations::FloatingIpCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpCreateWhen::new(when),
                operations::FloatingIpCreateThen::new(then),
            )
        })
    }

    fn floating_ip_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpViewWhen, operations::FloatingIpViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpViewWhen::new(when),
                operations::FloatingIpViewThen::new(then),
            )
        })
    }

    fn floating_ip_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpUpdateWhen, operations::FloatingIpUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpUpdateWhen::new(when),
                operations::FloatingIpUpdateThen::new(then),
            )
        })
    }

    fn floating_ip_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpDeleteWhen, operations::FloatingIpDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpDeleteWhen::new(when),
                operations::FloatingIpDeleteThen::new(then),
            )
        })
    }

    fn floating_ip_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpAttachWhen, operations::FloatingIpAttachThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpAttachWhen::new(when),
                operations::FloatingIpAttachThen::new(then),
            )
        })
    }

    fn floating_ip_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::FloatingIpDetachWhen, operations::FloatingIpDetachThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::FloatingIpDetachWhen::new(when),
                operations::FloatingIpDetachThen::new(then),
            )
        })
    }

    fn group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::GroupListWhen, operations::GroupListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::GroupListWhen::new(when),
                operations::GroupListThen::new(then),
            )
        })
    }

    fn group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::GroupViewWhen, operations::GroupViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::GroupViewWhen::new(when),
                operations::GroupViewThen::new(then),
            )
        })
    }

    fn image_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageListWhen, operations::ImageListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ImageListWhen::new(when),
                operations::ImageListThen::new(then),
            )
        })
    }

    fn image_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageCreateWhen, operations::ImageCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ImageCreateWhen::new(when),
                operations::ImageCreateThen::new(then),
            )
        })
    }

    fn image_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageViewWhen, operations::ImageViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ImageViewWhen::new(when),
                operations::ImageViewThen::new(then),
            )
        })
    }

    fn image_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageDeleteWhen, operations::ImageDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ImageDeleteWhen::new(when),
                operations::ImageDeleteThen::new(then),
            )
        })
    }

    fn image_demote<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImageDemoteWhen, operations::ImageDemoteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ImageDemoteWhen::new(when),
                operations::ImageDemoteThen::new(then),
            )
        })
    }

    fn image_promote<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ImagePromoteWhen, operations::ImagePromoteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ImagePromoteWhen::new(when),
                operations::ImagePromoteThen::new(then),
            )
        })
    }

    fn instance_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceListWhen, operations::InstanceListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceListWhen::new(when),
                operations::InstanceListThen::new(then),
            )
        })
    }

    fn instance_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceCreateWhen, operations::InstanceCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceCreateWhen::new(when),
                operations::InstanceCreateThen::new(then),
            )
        })
    }

    fn instance_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceViewWhen, operations::InstanceViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceViewWhen::new(when),
                operations::InstanceViewThen::new(then),
            )
        })
    }

    fn instance_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceUpdateWhen, operations::InstanceUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceUpdateWhen::new(when),
                operations::InstanceUpdateThen::new(then),
            )
        })
    }

    fn instance_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDeleteWhen, operations::InstanceDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceDeleteWhen::new(when),
                operations::InstanceDeleteThen::new(then),
            )
        })
    }

    fn instance_affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceAffinityGroupListWhen,
            operations::InstanceAffinityGroupListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceAffinityGroupListWhen::new(when),
                operations::InstanceAffinityGroupListThen::new(then),
            )
        })
    }

    fn instance_anti_affinity_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceAntiAffinityGroupListWhen,
            operations::InstanceAntiAffinityGroupListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceAntiAffinityGroupListWhen::new(when),
                operations::InstanceAntiAffinityGroupListThen::new(then),
            )
        })
    }

    fn instance_disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDiskListWhen, operations::InstanceDiskListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceDiskListWhen::new(when),
                operations::InstanceDiskListThen::new(then),
            )
        })
    }

    fn instance_disk_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDiskAttachWhen, operations::InstanceDiskAttachThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceDiskAttachWhen::new(when),
                operations::InstanceDiskAttachThen::new(then),
            )
        })
    }

    fn instance_disk_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceDiskDetachWhen, operations::InstanceDiskDetachThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceDiskDetachWhen::new(when),
                operations::InstanceDiskDetachThen::new(then),
            )
        })
    }

    fn instance_external_ip_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceExternalIpListWhen, operations::InstanceExternalIpListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceExternalIpListWhen::new(when),
                operations::InstanceExternalIpListThen::new(then),
            )
        })
    }

    fn instance_ephemeral_ip_attach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceEphemeralIpAttachWhen,
            operations::InstanceEphemeralIpAttachThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceEphemeralIpAttachWhen::new(when),
                operations::InstanceEphemeralIpAttachThen::new(then),
            )
        })
    }

    fn instance_ephemeral_ip_detach<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceEphemeralIpDetachWhen,
            operations::InstanceEphemeralIpDetachThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceEphemeralIpDetachWhen::new(when),
                operations::InstanceEphemeralIpDetachThen::new(then),
            )
        })
    }

    fn instance_external_subnet_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceExternalSubnetListWhen,
            operations::InstanceExternalSubnetListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceExternalSubnetListWhen::new(when),
                operations::InstanceExternalSubnetListThen::new(then),
            )
        })
    }

    fn instance_multicast_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceMulticastGroupListWhen,
            operations::InstanceMulticastGroupListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceMulticastGroupListWhen::new(when),
                operations::InstanceMulticastGroupListThen::new(then),
            )
        })
    }

    fn instance_multicast_group_join<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceMulticastGroupJoinWhen,
            operations::InstanceMulticastGroupJoinThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceMulticastGroupJoinWhen::new(when),
                operations::InstanceMulticastGroupJoinThen::new(then),
            )
        })
    }

    fn instance_multicast_group_leave<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceMulticastGroupLeaveWhen,
            operations::InstanceMulticastGroupLeaveThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceMulticastGroupLeaveWhen::new(when),
                operations::InstanceMulticastGroupLeaveThen::new(then),
            )
        })
    }

    fn instance_reboot<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceRebootWhen, operations::InstanceRebootThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceRebootWhen::new(when),
                operations::InstanceRebootThen::new(then),
            )
        })
    }

    fn instance_serial_console<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceSerialConsoleWhen, operations::InstanceSerialConsoleThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceSerialConsoleWhen::new(when),
                operations::InstanceSerialConsoleThen::new(then),
            )
        })
    }

    fn instance_serial_console_stream<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceSerialConsoleStreamWhen,
            operations::InstanceSerialConsoleStreamThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceSerialConsoleStreamWhen::new(when),
                operations::InstanceSerialConsoleStreamThen::new(then),
            )
        })
    }

    fn instance_ssh_public_key_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceSshPublicKeyListWhen,
            operations::InstanceSshPublicKeyListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceSshPublicKeyListWhen::new(when),
                operations::InstanceSshPublicKeyListThen::new(then),
            )
        })
    }

    fn instance_start<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceStartWhen, operations::InstanceStartThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceStartWhen::new(when),
                operations::InstanceStartThen::new(then),
            )
        })
    }

    fn instance_stop<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InstanceStopWhen, operations::InstanceStopThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceStopWhen::new(when),
                operations::InstanceStopThen::new(then),
            )
        })
    }

    fn internet_gateway_ip_address_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpAddressListWhen,
            operations::InternetGatewayIpAddressListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayIpAddressListWhen::new(when),
                operations::InternetGatewayIpAddressListThen::new(then),
            )
        })
    }

    fn internet_gateway_ip_address_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpAddressCreateWhen,
            operations::InternetGatewayIpAddressCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayIpAddressCreateWhen::new(when),
                operations::InternetGatewayIpAddressCreateThen::new(then),
            )
        })
    }

    fn internet_gateway_ip_address_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpAddressDeleteWhen,
            operations::InternetGatewayIpAddressDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayIpAddressDeleteWhen::new(when),
                operations::InternetGatewayIpAddressDeleteThen::new(then),
            )
        })
    }

    fn internet_gateway_ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpPoolListWhen,
            operations::InternetGatewayIpPoolListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayIpPoolListWhen::new(when),
                operations::InternetGatewayIpPoolListThen::new(then),
            )
        })
    }

    fn internet_gateway_ip_pool_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpPoolCreateWhen,
            operations::InternetGatewayIpPoolCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayIpPoolCreateWhen::new(when),
                operations::InternetGatewayIpPoolCreateThen::new(then),
            )
        })
    }

    fn internet_gateway_ip_pool_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InternetGatewayIpPoolDeleteWhen,
            operations::InternetGatewayIpPoolDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayIpPoolDeleteWhen::new(when),
                operations::InternetGatewayIpPoolDeleteThen::new(then),
            )
        })
    }

    fn internet_gateway_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayListWhen, operations::InternetGatewayListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayListWhen::new(when),
                operations::InternetGatewayListThen::new(then),
            )
        })
    }

    fn internet_gateway_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayCreateWhen, operations::InternetGatewayCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayCreateWhen::new(when),
                operations::InternetGatewayCreateThen::new(then),
            )
        })
    }

    fn internet_gateway_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayViewWhen, operations::InternetGatewayViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayViewWhen::new(when),
                operations::InternetGatewayViewThen::new(then),
            )
        })
    }

    fn internet_gateway_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::InternetGatewayDeleteWhen, operations::InternetGatewayDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InternetGatewayDeleteWhen::new(when),
                operations::InternetGatewayDeleteThen::new(then),
            )
        })
    }

    fn ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::IpPoolListWhen, operations::IpPoolListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::IpPoolListWhen::new(when),
                operations::IpPoolListThen::new(then),
            )
        })
    }

    fn ip_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::IpPoolViewWhen, operations::IpPoolViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::IpPoolViewWhen::new(when),
                operations::IpPoolViewThen::new(then),
            )
        })
    }

    fn login_local<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LoginLocalWhen, operations::LoginLocalThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::LoginLocalWhen::new(when),
                operations::LoginLocalThen::new(then),
            )
        })
    }

    fn logout<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LogoutWhen, operations::LogoutThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::LogoutWhen::new(when),
                operations::LogoutThen::new(then),
            )
        })
    }

    fn current_user_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserViewWhen, operations::CurrentUserViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserViewWhen::new(when),
                operations::CurrentUserViewThen::new(then),
            )
        })
    }

    fn current_user_access_token_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::CurrentUserAccessTokenListWhen,
            operations::CurrentUserAccessTokenListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserAccessTokenListWhen::new(when),
                operations::CurrentUserAccessTokenListThen::new(then),
            )
        })
    }

    fn current_user_access_token_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::CurrentUserAccessTokenDeleteWhen,
            operations::CurrentUserAccessTokenDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserAccessTokenDeleteWhen::new(when),
                operations::CurrentUserAccessTokenDeleteThen::new(then),
            )
        })
    }

    fn current_user_groups<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserGroupsWhen, operations::CurrentUserGroupsThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserGroupsWhen::new(when),
                operations::CurrentUserGroupsThen::new(then),
            )
        })
    }

    fn current_user_ssh_key_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyListWhen, operations::CurrentUserSshKeyListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserSshKeyListWhen::new(when),
                operations::CurrentUserSshKeyListThen::new(then),
            )
        })
    }

    fn current_user_ssh_key_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyCreateWhen, operations::CurrentUserSshKeyCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserSshKeyCreateWhen::new(when),
                operations::CurrentUserSshKeyCreateThen::new(then),
            )
        })
    }

    fn current_user_ssh_key_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyViewWhen, operations::CurrentUserSshKeyViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserSshKeyViewWhen::new(when),
                operations::CurrentUserSshKeyViewThen::new(then),
            )
        })
    }

    fn current_user_ssh_key_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::CurrentUserSshKeyDeleteWhen, operations::CurrentUserSshKeyDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::CurrentUserSshKeyDeleteWhen::new(when),
                operations::CurrentUserSshKeyDeleteThen::new(then),
            )
        })
    }

    fn silo_metric<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloMetricWhen, operations::SiloMetricThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloMetricWhen::new(when),
                operations::SiloMetricThen::new(then),
            )
        })
    }

    fn multicast_group_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::MulticastGroupListWhen, operations::MulticastGroupListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::MulticastGroupListWhen::new(when),
                operations::MulticastGroupListThen::new(then),
            )
        })
    }

    fn multicast_group_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::MulticastGroupViewWhen, operations::MulticastGroupViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::MulticastGroupViewWhen::new(when),
                operations::MulticastGroupViewThen::new(then),
            )
        })
    }

    fn multicast_group_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::MulticastGroupMemberListWhen,
            operations::MulticastGroupMemberListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::MulticastGroupMemberListWhen::new(when),
                operations::MulticastGroupMemberListThen::new(then),
            )
        })
    }

    fn instance_network_interface_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceListWhen,
            operations::InstanceNetworkInterfaceListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceNetworkInterfaceListWhen::new(when),
                operations::InstanceNetworkInterfaceListThen::new(then),
            )
        })
    }

    fn instance_network_interface_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceCreateWhen,
            operations::InstanceNetworkInterfaceCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceNetworkInterfaceCreateWhen::new(when),
                operations::InstanceNetworkInterfaceCreateThen::new(then),
            )
        })
    }

    fn instance_network_interface_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceViewWhen,
            operations::InstanceNetworkInterfaceViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceNetworkInterfaceViewWhen::new(when),
                operations::InstanceNetworkInterfaceViewThen::new(then),
            )
        })
    }

    fn instance_network_interface_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceUpdateWhen,
            operations::InstanceNetworkInterfaceUpdateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceNetworkInterfaceUpdateWhen::new(when),
                operations::InstanceNetworkInterfaceUpdateThen::new(then),
            )
        })
    }

    fn instance_network_interface_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::InstanceNetworkInterfaceDeleteWhen,
            operations::InstanceNetworkInterfaceDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::InstanceNetworkInterfaceDeleteWhen::new(when),
                operations::InstanceNetworkInterfaceDeleteThen::new(then),
            )
        })
    }

    fn ping<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PingWhen, operations::PingThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::PingWhen::new(when),
                operations::PingThen::new(then),
            )
        })
    }

    fn policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PolicyViewWhen, operations::PolicyViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::PolicyViewWhen::new(when),
                operations::PolicyViewThen::new(then),
            )
        })
    }

    fn policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PolicyUpdateWhen, operations::PolicyUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::PolicyUpdateWhen::new(when),
                operations::PolicyUpdateThen::new(then),
            )
        })
    }

    fn project_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectListWhen, operations::ProjectListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectListWhen::new(when),
                operations::ProjectListThen::new(then),
            )
        })
    }

    fn project_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectCreateWhen, operations::ProjectCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectCreateWhen::new(when),
                operations::ProjectCreateThen::new(then),
            )
        })
    }

    fn project_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectViewWhen, operations::ProjectViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectViewWhen::new(when),
                operations::ProjectViewThen::new(then),
            )
        })
    }

    fn project_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectUpdateWhen, operations::ProjectUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectUpdateWhen::new(when),
                operations::ProjectUpdateThen::new(then),
            )
        })
    }

    fn project_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectDeleteWhen, operations::ProjectDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectDeleteWhen::new(when),
                operations::ProjectDeleteThen::new(then),
            )
        })
    }

    fn project_policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectPolicyViewWhen, operations::ProjectPolicyViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectPolicyViewWhen::new(when),
                operations::ProjectPolicyViewThen::new(then),
            )
        })
    }

    fn project_policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ProjectPolicyUpdateWhen, operations::ProjectPolicyUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ProjectPolicyUpdateWhen::new(when),
                operations::ProjectPolicyUpdateThen::new(then),
            )
        })
    }

    fn snapshot_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotListWhen, operations::SnapshotListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SnapshotListWhen::new(when),
                operations::SnapshotListThen::new(then),
            )
        })
    }

    fn snapshot_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotCreateWhen, operations::SnapshotCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SnapshotCreateWhen::new(when),
                operations::SnapshotCreateThen::new(then),
            )
        })
    }

    fn snapshot_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotViewWhen, operations::SnapshotViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SnapshotViewWhen::new(when),
                operations::SnapshotViewThen::new(then),
            )
        })
    }

    fn snapshot_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SnapshotDeleteWhen, operations::SnapshotDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SnapshotDeleteWhen::new(when),
                operations::SnapshotDeleteThen::new(then),
            )
        })
    }

    fn subnet_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SubnetPoolListWhen, operations::SubnetPoolListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SubnetPoolListWhen::new(when),
                operations::SubnetPoolListThen::new(then),
            )
        })
    }

    fn subnet_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SubnetPoolViewWhen, operations::SubnetPoolViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SubnetPoolViewWhen::new(when),
                operations::SubnetPoolViewThen::new(then),
            )
        })
    }

    fn audit_log_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::AuditLogListWhen, operations::AuditLogListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::AuditLogListWhen::new(when),
                operations::AuditLogListThen::new(then),
            )
        })
    }

    fn physical_disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PhysicalDiskListWhen, operations::PhysicalDiskListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::PhysicalDiskListWhen::new(when),
                operations::PhysicalDiskListThen::new(then),
            )
        })
    }

    fn physical_disk_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::PhysicalDiskViewWhen, operations::PhysicalDiskViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::PhysicalDiskViewWhen::new(when),
                operations::PhysicalDiskViewThen::new(then),
            )
        })
    }

    fn networking_switch_port_lldp_neighbors<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortLldpNeighborsWhen,
            operations::NetworkingSwitchPortLldpNeighborsThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortLldpNeighborsWhen::new(when),
                operations::NetworkingSwitchPortLldpNeighborsThen::new(then),
            )
        })
    }

    fn rack_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackListWhen, operations::RackListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::RackListWhen::new(when),
                operations::RackListThen::new(then),
            )
        })
    }

    fn rack_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackViewWhen, operations::RackViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::RackViewWhen::new(when),
                operations::RackViewThen::new(then),
            )
        })
    }

    fn rack_membership_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackMembershipStatusWhen, operations::RackMembershipStatusThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::RackMembershipStatusWhen::new(when),
                operations::RackMembershipStatusThen::new(then),
            )
        })
    }

    fn rack_membership_abort<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackMembershipAbortWhen, operations::RackMembershipAbortThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::RackMembershipAbortWhen::new(when),
                operations::RackMembershipAbortThen::new(then),
            )
        })
    }

    fn rack_membership_add_sleds<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::RackMembershipAddSledsWhen, operations::RackMembershipAddSledsThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::RackMembershipAddSledsWhen::new(when),
                operations::RackMembershipAddSledsThen::new(then),
            )
        })
    }

    fn sled_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledListWhen, operations::SledListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledListWhen::new(when),
                operations::SledListThen::new(then),
            )
        })
    }

    fn sled_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledAddWhen, operations::SledAddThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledAddWhen::new(when),
                operations::SledAddThen::new(then),
            )
        })
    }

    fn sled_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledViewWhen, operations::SledViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledViewWhen::new(when),
                operations::SledViewThen::new(then),
            )
        })
    }

    fn sled_physical_disk_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledPhysicalDiskListWhen, operations::SledPhysicalDiskListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledPhysicalDiskListWhen::new(when),
                operations::SledPhysicalDiskListThen::new(then),
            )
        })
    }

    fn sled_instance_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledInstanceListWhen, operations::SledInstanceListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledInstanceListWhen::new(when),
                operations::SledInstanceListThen::new(then),
            )
        })
    }

    fn sled_set_provision_policy<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledSetProvisionPolicyWhen, operations::SledSetProvisionPolicyThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledSetProvisionPolicyWhen::new(when),
                operations::SledSetProvisionPolicyThen::new(then),
            )
        })
    }

    fn sled_list_uninitialized<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SledListUninitializedWhen, operations::SledListUninitializedThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SledListUninitializedWhen::new(when),
                operations::SledListUninitializedThen::new(then),
            )
        })
    }

    fn networking_switch_port_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortListWhen,
            operations::NetworkingSwitchPortListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortListWhen::new(when),
                operations::NetworkingSwitchPortListThen::new(then),
            )
        })
    }

    fn networking_switch_port_lldp_config_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortLldpConfigViewWhen,
            operations::NetworkingSwitchPortLldpConfigViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortLldpConfigViewWhen::new(when),
                operations::NetworkingSwitchPortLldpConfigViewThen::new(then),
            )
        })
    }

    fn networking_switch_port_lldp_config_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortLldpConfigUpdateWhen,
            operations::NetworkingSwitchPortLldpConfigUpdateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortLldpConfigUpdateWhen::new(when),
                operations::NetworkingSwitchPortLldpConfigUpdateThen::new(then),
            )
        })
    }

    fn networking_switch_port_apply_settings<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortApplySettingsWhen,
            operations::NetworkingSwitchPortApplySettingsThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortApplySettingsWhen::new(when),
                operations::NetworkingSwitchPortApplySettingsThen::new(then),
            )
        })
    }

    fn networking_switch_port_clear_settings<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortClearSettingsWhen,
            operations::NetworkingSwitchPortClearSettingsThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortClearSettingsWhen::new(when),
                operations::NetworkingSwitchPortClearSettingsThen::new(then),
            )
        })
    }

    fn networking_switch_port_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortStatusWhen,
            operations::NetworkingSwitchPortStatusThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortStatusWhen::new(when),
                operations::NetworkingSwitchPortStatusThen::new(then),
            )
        })
    }

    fn switch_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SwitchListWhen, operations::SwitchListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SwitchListWhen::new(when),
                operations::SwitchListThen::new(then),
            )
        })
    }

    fn switch_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SwitchViewWhen, operations::SwitchViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SwitchViewWhen::new(when),
                operations::SwitchViewThen::new(then),
            )
        })
    }

    fn silo_identity_provider_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SiloIdentityProviderListWhen,
            operations::SiloIdentityProviderListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloIdentityProviderListWhen::new(when),
                operations::SiloIdentityProviderListThen::new(then),
            )
        })
    }

    fn local_idp_user_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LocalIdpUserCreateWhen, operations::LocalIdpUserCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::LocalIdpUserCreateWhen::new(when),
                operations::LocalIdpUserCreateThen::new(then),
            )
        })
    }

    fn local_idp_user_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LocalIdpUserDeleteWhen, operations::LocalIdpUserDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::LocalIdpUserDeleteWhen::new(when),
                operations::LocalIdpUserDeleteThen::new(then),
            )
        })
    }

    fn local_idp_user_set_password<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::LocalIdpUserSetPasswordWhen, operations::LocalIdpUserSetPasswordThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::LocalIdpUserSetPasswordWhen::new(when),
                operations::LocalIdpUserSetPasswordThen::new(then),
            )
        })
    }

    fn saml_identity_provider_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SamlIdentityProviderCreateWhen,
            operations::SamlIdentityProviderCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SamlIdentityProviderCreateWhen::new(when),
                operations::SamlIdentityProviderCreateThen::new(then),
            )
        })
    }

    fn saml_identity_provider_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SamlIdentityProviderViewWhen,
            operations::SamlIdentityProviderViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SamlIdentityProviderViewWhen::new(when),
                operations::SamlIdentityProviderViewThen::new(then),
            )
        })
    }

    fn system_ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolListWhen, operations::SystemIpPoolListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolListWhen::new(when),
                operations::SystemIpPoolListThen::new(then),
            )
        })
    }

    fn system_ip_pool_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolCreateWhen, operations::SystemIpPoolCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolCreateWhen::new(when),
                operations::SystemIpPoolCreateThen::new(then),
            )
        })
    }

    fn system_ip_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolViewWhen, operations::SystemIpPoolViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolViewWhen::new(when),
                operations::SystemIpPoolViewThen::new(then),
            )
        })
    }

    fn system_ip_pool_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolUpdateWhen, operations::SystemIpPoolUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolUpdateWhen::new(when),
                operations::SystemIpPoolUpdateThen::new(then),
            )
        })
    }

    fn system_ip_pool_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolDeleteWhen, operations::SystemIpPoolDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolDeleteWhen::new(when),
                operations::SystemIpPoolDeleteThen::new(then),
            )
        })
    }

    fn system_ip_pool_range_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolRangeListWhen, operations::SystemIpPoolRangeListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolRangeListWhen::new(when),
                operations::SystemIpPoolRangeListThen::new(then),
            )
        })
    }

    fn system_ip_pool_range_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolRangeAddWhen, operations::SystemIpPoolRangeAddThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolRangeAddWhen::new(when),
                operations::SystemIpPoolRangeAddThen::new(then),
            )
        })
    }

    fn system_ip_pool_range_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolRangeRemoveWhen, operations::SystemIpPoolRangeRemoveThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolRangeRemoveWhen::new(when),
                operations::SystemIpPoolRangeRemoveThen::new(then),
            )
        })
    }

    fn system_ip_pool_silo_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloListWhen, operations::SystemIpPoolSiloListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolSiloListWhen::new(when),
                operations::SystemIpPoolSiloListThen::new(then),
            )
        })
    }

    fn system_ip_pool_silo_link<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloLinkWhen, operations::SystemIpPoolSiloLinkThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolSiloLinkWhen::new(when),
                operations::SystemIpPoolSiloLinkThen::new(then),
            )
        })
    }

    fn system_ip_pool_silo_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloUpdateWhen, operations::SystemIpPoolSiloUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolSiloUpdateWhen::new(when),
                operations::SystemIpPoolSiloUpdateThen::new(then),
            )
        })
    }

    fn system_ip_pool_silo_unlink<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolSiloUnlinkWhen, operations::SystemIpPoolSiloUnlinkThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolSiloUnlinkWhen::new(when),
                operations::SystemIpPoolSiloUnlinkThen::new(then),
            )
        })
    }

    fn system_ip_pool_utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolUtilizationViewWhen,
            operations::SystemIpPoolUtilizationViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolUtilizationViewWhen::new(when),
                operations::SystemIpPoolUtilizationViewThen::new(then),
            )
        })
    }

    fn system_ip_pool_service_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemIpPoolServiceViewWhen, operations::SystemIpPoolServiceViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolServiceViewWhen::new(when),
                operations::SystemIpPoolServiceViewThen::new(then),
            )
        })
    }

    fn system_ip_pool_service_range_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolServiceRangeListWhen,
            operations::SystemIpPoolServiceRangeListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolServiceRangeListWhen::new(when),
                operations::SystemIpPoolServiceRangeListThen::new(then),
            )
        })
    }

    fn system_ip_pool_service_range_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolServiceRangeAddWhen,
            operations::SystemIpPoolServiceRangeAddThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolServiceRangeAddWhen::new(when),
                operations::SystemIpPoolServiceRangeAddThen::new(then),
            )
        })
    }

    fn system_ip_pool_service_range_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemIpPoolServiceRangeRemoveWhen,
            operations::SystemIpPoolServiceRangeRemoveThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemIpPoolServiceRangeRemoveWhen::new(when),
                operations::SystemIpPoolServiceRangeRemoveThen::new(then),
            )
        })
    }

    fn system_metric<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemMetricWhen, operations::SystemMetricThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemMetricWhen::new(when),
                operations::SystemMetricThen::new(then),
            )
        })
    }

    fn networking_address_lot_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotListWhen,
            operations::NetworkingAddressLotListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAddressLotListWhen::new(when),
                operations::NetworkingAddressLotListThen::new(then),
            )
        })
    }

    fn networking_address_lot_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotCreateWhen,
            operations::NetworkingAddressLotCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAddressLotCreateWhen::new(when),
                operations::NetworkingAddressLotCreateThen::new(then),
            )
        })
    }

    fn networking_address_lot_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotViewWhen,
            operations::NetworkingAddressLotViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAddressLotViewWhen::new(when),
                operations::NetworkingAddressLotViewThen::new(then),
            )
        })
    }

    fn networking_address_lot_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotDeleteWhen,
            operations::NetworkingAddressLotDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAddressLotDeleteWhen::new(when),
                operations::NetworkingAddressLotDeleteThen::new(then),
            )
        })
    }

    fn networking_address_lot_block_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAddressLotBlockListWhen,
            operations::NetworkingAddressLotBlockListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAddressLotBlockListWhen::new(when),
                operations::NetworkingAddressLotBlockListThen::new(then),
            )
        })
    }

    fn networking_allow_list_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingAllowListViewWhen, operations::NetworkingAllowListViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAllowListViewWhen::new(when),
                operations::NetworkingAllowListViewThen::new(then),
            )
        })
    }

    fn networking_allow_list_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingAllowListUpdateWhen,
            operations::NetworkingAllowListUpdateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingAllowListUpdateWhen::new(when),
                operations::NetworkingAllowListUpdateThen::new(then),
            )
        })
    }

    fn networking_bfd_disable<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBfdDisableWhen, operations::NetworkingBfdDisableThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBfdDisableWhen::new(when),
                operations::NetworkingBfdDisableThen::new(then),
            )
        })
    }

    fn networking_bfd_enable<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBfdEnableWhen, operations::NetworkingBfdEnableThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBfdEnableWhen::new(when),
                operations::NetworkingBfdEnableThen::new(then),
            )
        })
    }

    fn networking_bfd_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBfdStatusWhen, operations::NetworkingBfdStatusThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBfdStatusWhen::new(when),
                operations::NetworkingBfdStatusThen::new(then),
            )
        })
    }

    fn networking_bgp_config_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpConfigListWhen, operations::NetworkingBgpConfigListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpConfigListWhen::new(when),
                operations::NetworkingBgpConfigListThen::new(then),
            )
        })
    }

    fn networking_bgp_config_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpConfigCreateWhen,
            operations::NetworkingBgpConfigCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpConfigCreateWhen::new(when),
                operations::NetworkingBgpConfigCreateThen::new(then),
            )
        })
    }

    fn networking_bgp_config_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpConfigDeleteWhen,
            operations::NetworkingBgpConfigDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpConfigDeleteWhen::new(when),
                operations::NetworkingBgpConfigDeleteThen::new(then),
            )
        })
    }

    fn networking_bgp_announce_set_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnounceSetListWhen,
            operations::NetworkingBgpAnnounceSetListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpAnnounceSetListWhen::new(when),
                operations::NetworkingBgpAnnounceSetListThen::new(then),
            )
        })
    }

    fn networking_bgp_announce_set_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnounceSetUpdateWhen,
            operations::NetworkingBgpAnnounceSetUpdateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpAnnounceSetUpdateWhen::new(when),
                operations::NetworkingBgpAnnounceSetUpdateThen::new(then),
            )
        })
    }

    fn networking_bgp_announce_set_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnounceSetDeleteWhen,
            operations::NetworkingBgpAnnounceSetDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpAnnounceSetDeleteWhen::new(when),
                operations::NetworkingBgpAnnounceSetDeleteThen::new(then),
            )
        })
    }

    fn networking_bgp_announcement_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpAnnouncementListWhen,
            operations::NetworkingBgpAnnouncementListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpAnnouncementListWhen::new(when),
                operations::NetworkingBgpAnnouncementListThen::new(then),
            )
        })
    }

    fn networking_bgp_exported<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpExportedWhen, operations::NetworkingBgpExportedThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpExportedWhen::new(when),
                operations::NetworkingBgpExportedThen::new(then),
            )
        })
    }

    fn networking_bgp_imported<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpImportedWhen, operations::NetworkingBgpImportedThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpImportedWhen::new(when),
                operations::NetworkingBgpImportedThen::new(then),
            )
        })
    }

    fn networking_bgp_message_history<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingBgpMessageHistoryWhen,
            operations::NetworkingBgpMessageHistoryThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpMessageHistoryWhen::new(when),
                operations::NetworkingBgpMessageHistoryThen::new(then),
            )
        })
    }

    fn networking_bgp_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::NetworkingBgpStatusWhen, operations::NetworkingBgpStatusThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingBgpStatusWhen::new(when),
                operations::NetworkingBgpStatusThen::new(then),
            )
        })
    }

    fn networking_inbound_icmp_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingInboundIcmpViewWhen,
            operations::NetworkingInboundIcmpViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingInboundIcmpViewWhen::new(when),
                operations::NetworkingInboundIcmpViewThen::new(then),
            )
        })
    }

    fn networking_inbound_icmp_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingInboundIcmpUpdateWhen,
            operations::NetworkingInboundIcmpUpdateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingInboundIcmpUpdateWhen::new(when),
                operations::NetworkingInboundIcmpUpdateThen::new(then),
            )
        })
    }

    fn networking_loopback_address_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingLoopbackAddressListWhen,
            operations::NetworkingLoopbackAddressListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingLoopbackAddressListWhen::new(when),
                operations::NetworkingLoopbackAddressListThen::new(then),
            )
        })
    }

    fn networking_loopback_address_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingLoopbackAddressCreateWhen,
            operations::NetworkingLoopbackAddressCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingLoopbackAddressCreateWhen::new(when),
                operations::NetworkingLoopbackAddressCreateThen::new(then),
            )
        })
    }

    fn networking_loopback_address_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingLoopbackAddressDeleteWhen,
            operations::NetworkingLoopbackAddressDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingLoopbackAddressDeleteWhen::new(when),
                operations::NetworkingLoopbackAddressDeleteThen::new(then),
            )
        })
    }

    fn networking_switch_port_settings_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsListWhen,
            operations::NetworkingSwitchPortSettingsListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortSettingsListWhen::new(when),
                operations::NetworkingSwitchPortSettingsListThen::new(then),
            )
        })
    }

    fn networking_switch_port_settings_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsCreateWhen,
            operations::NetworkingSwitchPortSettingsCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortSettingsCreateWhen::new(when),
                operations::NetworkingSwitchPortSettingsCreateThen::new(then),
            )
        })
    }

    fn networking_switch_port_settings_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsDeleteWhen,
            operations::NetworkingSwitchPortSettingsDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortSettingsDeleteWhen::new(when),
                operations::NetworkingSwitchPortSettingsDeleteThen::new(then),
            )
        })
    }

    fn networking_switch_port_settings_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::NetworkingSwitchPortSettingsViewWhen,
            operations::NetworkingSwitchPortSettingsViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::NetworkingSwitchPortSettingsViewWhen::new(when),
                operations::NetworkingSwitchPortSettingsViewThen::new(then),
            )
        })
    }

    fn system_policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemPolicyViewWhen, operations::SystemPolicyViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemPolicyViewWhen::new(when),
                operations::SystemPolicyViewThen::new(then),
            )
        })
    }

    fn system_policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemPolicyUpdateWhen, operations::SystemPolicyUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemPolicyUpdateWhen::new(when),
                operations::SystemPolicyUpdateThen::new(then),
            )
        })
    }

    fn scim_token_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenListWhen, operations::ScimTokenListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ScimTokenListWhen::new(when),
                operations::ScimTokenListThen::new(then),
            )
        })
    }

    fn scim_token_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenCreateWhen, operations::ScimTokenCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ScimTokenCreateWhen::new(when),
                operations::ScimTokenCreateThen::new(then),
            )
        })
    }

    fn scim_token_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenViewWhen, operations::ScimTokenViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ScimTokenViewWhen::new(when),
                operations::ScimTokenViewThen::new(then),
            )
        })
    }

    fn scim_token_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::ScimTokenDeleteWhen, operations::ScimTokenDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::ScimTokenDeleteWhen::new(when),
                operations::ScimTokenDeleteThen::new(then),
            )
        })
    }

    fn system_quotas_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemQuotasListWhen, operations::SystemQuotasListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemQuotasListWhen::new(when),
                operations::SystemQuotasListThen::new(then),
            )
        })
    }

    fn silo_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloListWhen, operations::SiloListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloListWhen::new(when),
                operations::SiloListThen::new(then),
            )
        })
    }

    fn silo_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloCreateWhen, operations::SiloCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloCreateWhen::new(when),
                operations::SiloCreateThen::new(then),
            )
        })
    }

    fn silo_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloViewWhen, operations::SiloViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloViewWhen::new(when),
                operations::SiloViewThen::new(then),
            )
        })
    }

    fn silo_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloDeleteWhen, operations::SiloDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloDeleteWhen::new(when),
                operations::SiloDeleteThen::new(then),
            )
        })
    }

    fn silo_ip_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloIpPoolListWhen, operations::SiloIpPoolListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloIpPoolListWhen::new(when),
                operations::SiloIpPoolListThen::new(then),
            )
        })
    }

    fn silo_policy_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloPolicyViewWhen, operations::SiloPolicyViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloPolicyViewWhen::new(when),
                operations::SiloPolicyViewThen::new(then),
            )
        })
    }

    fn silo_policy_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloPolicyUpdateWhen, operations::SiloPolicyUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloPolicyUpdateWhen::new(when),
                operations::SiloPolicyUpdateThen::new(then),
            )
        })
    }

    fn silo_quotas_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloQuotasViewWhen, operations::SiloQuotasViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloQuotasViewWhen::new(when),
                operations::SiloQuotasViewThen::new(then),
            )
        })
    }

    fn silo_quotas_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloQuotasUpdateWhen, operations::SiloQuotasUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloQuotasUpdateWhen::new(when),
                operations::SiloQuotasUpdateThen::new(then),
            )
        })
    }

    fn silo_subnet_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloSubnetPoolListWhen, operations::SiloSubnetPoolListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloSubnetPoolListWhen::new(when),
                operations::SiloSubnetPoolListThen::new(then),
            )
        })
    }

    fn system_subnet_pool_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolListWhen, operations::SystemSubnetPoolListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolListWhen::new(when),
                operations::SystemSubnetPoolListThen::new(then),
            )
        })
    }

    fn system_subnet_pool_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolCreateWhen, operations::SystemSubnetPoolCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolCreateWhen::new(when),
                operations::SystemSubnetPoolCreateThen::new(then),
            )
        })
    }

    fn system_subnet_pool_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolViewWhen, operations::SystemSubnetPoolViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolViewWhen::new(when),
                operations::SystemSubnetPoolViewThen::new(then),
            )
        })
    }

    fn system_subnet_pool_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolUpdateWhen, operations::SystemSubnetPoolUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolUpdateWhen::new(when),
                operations::SystemSubnetPoolUpdateThen::new(then),
            )
        })
    }

    fn system_subnet_pool_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemSubnetPoolDeleteWhen, operations::SystemSubnetPoolDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolDeleteWhen::new(when),
                operations::SystemSubnetPoolDeleteThen::new(then),
            )
        })
    }

    fn system_subnet_pool_member_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolMemberListWhen,
            operations::SystemSubnetPoolMemberListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolMemberListWhen::new(when),
                operations::SystemSubnetPoolMemberListThen::new(then),
            )
        })
    }

    fn system_subnet_pool_member_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolMemberAddWhen,
            operations::SystemSubnetPoolMemberAddThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolMemberAddWhen::new(when),
                operations::SystemSubnetPoolMemberAddThen::new(then),
            )
        })
    }

    fn system_subnet_pool_member_remove<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolMemberRemoveWhen,
            operations::SystemSubnetPoolMemberRemoveThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolMemberRemoveWhen::new(when),
                operations::SystemSubnetPoolMemberRemoveThen::new(then),
            )
        })
    }

    fn system_subnet_pool_silo_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloListWhen,
            operations::SystemSubnetPoolSiloListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolSiloListWhen::new(when),
                operations::SystemSubnetPoolSiloListThen::new(then),
            )
        })
    }

    fn system_subnet_pool_silo_link<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloLinkWhen,
            operations::SystemSubnetPoolSiloLinkThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolSiloLinkWhen::new(when),
                operations::SystemSubnetPoolSiloLinkThen::new(then),
            )
        })
    }

    fn system_subnet_pool_silo_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloUpdateWhen,
            operations::SystemSubnetPoolSiloUpdateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolSiloUpdateWhen::new(when),
                operations::SystemSubnetPoolSiloUpdateThen::new(then),
            )
        })
    }

    fn system_subnet_pool_silo_unlink<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolSiloUnlinkWhen,
            operations::SystemSubnetPoolSiloUnlinkThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolSiloUnlinkWhen::new(when),
                operations::SystemSubnetPoolSiloUnlinkThen::new(then),
            )
        })
    }

    fn system_subnet_pool_utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemSubnetPoolUtilizationViewWhen,
            operations::SystemSubnetPoolUtilizationViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemSubnetPoolUtilizationViewWhen::new(when),
                operations::SystemSubnetPoolUtilizationViewThen::new(then),
            )
        })
    }

    fn system_timeseries_query<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemTimeseriesQueryWhen, operations::SystemTimeseriesQueryThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemTimeseriesQueryWhen::new(when),
                operations::SystemTimeseriesQueryThen::new(then),
            )
        })
    }

    fn system_timeseries_schema_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemTimeseriesSchemaListWhen,
            operations::SystemTimeseriesSchemaListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemTimeseriesSchemaListWhen::new(when),
                operations::SystemTimeseriesSchemaListThen::new(then),
            )
        })
    }

    fn system_update_repository_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateRepositoryListWhen,
            operations::SystemUpdateRepositoryListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateRepositoryListWhen::new(when),
                operations::SystemUpdateRepositoryListThen::new(then),
            )
        })
    }

    fn system_update_repository_upload<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateRepositoryUploadWhen,
            operations::SystemUpdateRepositoryUploadThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateRepositoryUploadWhen::new(when),
                operations::SystemUpdateRepositoryUploadThen::new(then),
            )
        })
    }

    fn system_update_repository_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateRepositoryViewWhen,
            operations::SystemUpdateRepositoryViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateRepositoryViewWhen::new(when),
                operations::SystemUpdateRepositoryViewThen::new(then),
            )
        })
    }

    fn system_update_status<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SystemUpdateStatusWhen, operations::SystemUpdateStatusThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateStatusWhen::new(when),
                operations::SystemUpdateStatusThen::new(then),
            )
        })
    }

    fn target_release_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::TargetReleaseUpdateWhen, operations::TargetReleaseUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::TargetReleaseUpdateWhen::new(when),
                operations::TargetReleaseUpdateThen::new(then),
            )
        })
    }

    fn system_update_trust_root_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootListWhen,
            operations::SystemUpdateTrustRootListThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateTrustRootListWhen::new(when),
                operations::SystemUpdateTrustRootListThen::new(then),
            )
        })
    }

    fn system_update_trust_root_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootCreateWhen,
            operations::SystemUpdateTrustRootCreateThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateTrustRootCreateWhen::new(when),
                operations::SystemUpdateTrustRootCreateThen::new(then),
            )
        })
    }

    fn system_update_trust_root_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootViewWhen,
            operations::SystemUpdateTrustRootViewThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateTrustRootViewWhen::new(when),
                operations::SystemUpdateTrustRootViewThen::new(then),
            )
        })
    }

    fn system_update_trust_root_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::SystemUpdateTrustRootDeleteWhen,
            operations::SystemUpdateTrustRootDeleteThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SystemUpdateTrustRootDeleteWhen::new(when),
                operations::SystemUpdateTrustRootDeleteThen::new(then),
            )
        })
    }

    fn silo_user_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUserListWhen, operations::SiloUserListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloUserListWhen::new(when),
                operations::SiloUserListThen::new(then),
            )
        })
    }

    fn silo_user_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUserViewWhen, operations::SiloUserViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloUserViewWhen::new(when),
                operations::SiloUserViewThen::new(then),
            )
        })
    }

    fn user_builtin_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserBuiltinListWhen, operations::UserBuiltinListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserBuiltinListWhen::new(when),
                operations::UserBuiltinListThen::new(then),
            )
        })
    }

    fn user_builtin_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserBuiltinViewWhen, operations::UserBuiltinViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserBuiltinViewWhen::new(when),
                operations::UserBuiltinViewThen::new(then),
            )
        })
    }

    fn silo_utilization_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUtilizationListWhen, operations::SiloUtilizationListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloUtilizationListWhen::new(when),
                operations::SiloUtilizationListThen::new(then),
            )
        })
    }

    fn silo_utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::SiloUtilizationViewWhen, operations::SiloUtilizationViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::SiloUtilizationViewWhen::new(when),
                operations::SiloUtilizationViewThen::new(then),
            )
        })
    }

    fn timeseries_query<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::TimeseriesQueryWhen, operations::TimeseriesQueryThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::TimeseriesQueryWhen::new(when),
                operations::TimeseriesQueryThen::new(then),
            )
        })
    }

    fn user_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserListWhen, operations::UserListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserListWhen::new(when),
                operations::UserListThen::new(then),
            )
        })
    }

    fn user_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserViewWhen, operations::UserViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserViewWhen::new(when),
                operations::UserViewThen::new(then),
            )
        })
    }

    fn user_token_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserTokenListWhen, operations::UserTokenListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserTokenListWhen::new(when),
                operations::UserTokenListThen::new(then),
            )
        })
    }

    fn user_logout<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserLogoutWhen, operations::UserLogoutThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserLogoutWhen::new(when),
                operations::UserLogoutThen::new(then),
            )
        })
    }

    fn user_session_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UserSessionListWhen, operations::UserSessionListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UserSessionListWhen::new(when),
                operations::UserSessionListThen::new(then),
            )
        })
    }

    fn utilization_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::UtilizationViewWhen, operations::UtilizationViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::UtilizationViewWhen::new(when),
                operations::UtilizationViewThen::new(then),
            )
        })
    }

    fn vpc_firewall_rules_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcFirewallRulesViewWhen, operations::VpcFirewallRulesViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcFirewallRulesViewWhen::new(when),
                operations::VpcFirewallRulesViewThen::new(then),
            )
        })
    }

    fn vpc_firewall_rules_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcFirewallRulesUpdateWhen, operations::VpcFirewallRulesUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcFirewallRulesUpdateWhen::new(when),
                operations::VpcFirewallRulesUpdateThen::new(then),
            )
        })
    }

    fn vpc_router_route_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteListWhen, operations::VpcRouterRouteListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterRouteListWhen::new(when),
                operations::VpcRouterRouteListThen::new(then),
            )
        })
    }

    fn vpc_router_route_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteCreateWhen, operations::VpcRouterRouteCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterRouteCreateWhen::new(when),
                operations::VpcRouterRouteCreateThen::new(then),
            )
        })
    }

    fn vpc_router_route_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteViewWhen, operations::VpcRouterRouteViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterRouteViewWhen::new(when),
                operations::VpcRouterRouteViewThen::new(then),
            )
        })
    }

    fn vpc_router_route_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteUpdateWhen, operations::VpcRouterRouteUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterRouteUpdateWhen::new(when),
                operations::VpcRouterRouteUpdateThen::new(then),
            )
        })
    }

    fn vpc_router_route_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterRouteDeleteWhen, operations::VpcRouterRouteDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterRouteDeleteWhen::new(when),
                operations::VpcRouterRouteDeleteThen::new(then),
            )
        })
    }

    fn vpc_router_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterListWhen, operations::VpcRouterListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterListWhen::new(when),
                operations::VpcRouterListThen::new(then),
            )
        })
    }

    fn vpc_router_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterCreateWhen, operations::VpcRouterCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterCreateWhen::new(when),
                operations::VpcRouterCreateThen::new(then),
            )
        })
    }

    fn vpc_router_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterViewWhen, operations::VpcRouterViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterViewWhen::new(when),
                operations::VpcRouterViewThen::new(then),
            )
        })
    }

    fn vpc_router_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterUpdateWhen, operations::VpcRouterUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterUpdateWhen::new(when),
                operations::VpcRouterUpdateThen::new(then),
            )
        })
    }

    fn vpc_router_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcRouterDeleteWhen, operations::VpcRouterDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcRouterDeleteWhen::new(when),
                operations::VpcRouterDeleteThen::new(then),
            )
        })
    }

    fn vpc_subnet_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetListWhen, operations::VpcSubnetListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcSubnetListWhen::new(when),
                operations::VpcSubnetListThen::new(then),
            )
        })
    }

    fn vpc_subnet_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetCreateWhen, operations::VpcSubnetCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcSubnetCreateWhen::new(when),
                operations::VpcSubnetCreateThen::new(then),
            )
        })
    }

    fn vpc_subnet_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetViewWhen, operations::VpcSubnetViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcSubnetViewWhen::new(when),
                operations::VpcSubnetViewThen::new(then),
            )
        })
    }

    fn vpc_subnet_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetUpdateWhen, operations::VpcSubnetUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcSubnetUpdateWhen::new(when),
                operations::VpcSubnetUpdateThen::new(then),
            )
        })
    }

    fn vpc_subnet_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcSubnetDeleteWhen, operations::VpcSubnetDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcSubnetDeleteWhen::new(when),
                operations::VpcSubnetDeleteThen::new(then),
            )
        })
    }

    fn vpc_subnet_list_network_interfaces<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(
            operations::VpcSubnetListNetworkInterfacesWhen,
            operations::VpcSubnetListNetworkInterfacesThen,
        ),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcSubnetListNetworkInterfacesWhen::new(when),
                operations::VpcSubnetListNetworkInterfacesThen::new(then),
            )
        })
    }

    fn vpc_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcListWhen, operations::VpcListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcListWhen::new(when),
                operations::VpcListThen::new(then),
            )
        })
    }

    fn vpc_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcCreateWhen, operations::VpcCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcCreateWhen::new(when),
                operations::VpcCreateThen::new(then),
            )
        })
    }

    fn vpc_view<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcViewWhen, operations::VpcViewThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcViewWhen::new(when),
                operations::VpcViewThen::new(then),
            )
        })
    }

    fn vpc_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcUpdateWhen, operations::VpcUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcUpdateWhen::new(when),
                operations::VpcUpdateThen::new(then),
            )
        })
    }

    fn vpc_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::VpcDeleteWhen, operations::VpcDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::VpcDeleteWhen::new(when),
                operations::VpcDeleteThen::new(then),
            )
        })
    }

    fn webhook_receiver_create<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookReceiverCreateWhen, operations::WebhookReceiverCreateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::WebhookReceiverCreateWhen::new(when),
                operations::WebhookReceiverCreateThen::new(then),
            )
        })
    }

    fn webhook_receiver_update<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookReceiverUpdateWhen, operations::WebhookReceiverUpdateThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::WebhookReceiverUpdateWhen::new(when),
                operations::WebhookReceiverUpdateThen::new(then),
            )
        })
    }

    fn webhook_secrets_list<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookSecretsListWhen, operations::WebhookSecretsListThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::WebhookSecretsListWhen::new(when),
                operations::WebhookSecretsListThen::new(then),
            )
        })
    }

    fn webhook_secrets_add<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookSecretsAddWhen, operations::WebhookSecretsAddThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::WebhookSecretsAddWhen::new(when),
                operations::WebhookSecretsAddThen::new(then),
            )
        })
    }

    fn webhook_secrets_delete<F>(&self, config_fn: F) -> ::httpmock::Mock<'_>
    where
        F: FnOnce(operations::WebhookSecretsDeleteWhen, operations::WebhookSecretsDeleteThen),
    {
        self.mock(|when, then| {
            config_fn(
                operations::WebhookSecretsDeleteWhen::new(when),
                operations::WebhookSecretsDeleteThen::new(then),
            )
        })
    }
}