// This file is @generated by prost-build.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeEvent {
    #[prost(oneof = "app_upgrade_event::Event", tags = "1, 2, 3, 4, 5, 6")]
    pub event: ::core::option::Option<app_upgrade_event::Event>,
}
/// Nested message and enum types in `AppUpgradeEvent`.
pub mod app_upgrade_event {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Event {
        #[prost(message, tag = "1")]
        DownloadStarting(super::AppUpgradeDownloadStarting),
        #[prost(message, tag = "2")]
        DownloadProgress(super::AppUpgradeDownloadProgress),
        #[prost(message, tag = "3")]
        UpgradeAborted(super::AppUpgradeAborted),
        #[prost(message, tag = "4")]
        VerifyingInstaller(super::AppUpgradeVerifyingInstaller),
        #[prost(message, tag = "5")]
        VerifiedInstaller(super::AppUpgradeVerifiedInstaller),
        #[prost(message, tag = "6")]
        Error(super::AppUpgradeError),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeDownloadStarting {}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeDownloadProgress {
    #[prost(string, tag = "1")]
    pub server: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub progress: u32,
    #[prost(message, optional, tag = "3")]
    pub time_left: ::core::option::Option<::prost_types::Duration>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeAborted {}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeVerifyingInstaller {}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeVerifiedInstaller {}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppUpgradeError {
    #[prost(enumeration = "app_upgrade_error::Error", tag = "1")]
    pub error: i32,
}
/// Nested message and enum types in `AppUpgradeError`.
pub mod app_upgrade_error {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Error {
        GeneralError = 0,
        DownloadFailed = 1,
        VerificationFailed = 2,
    }
    impl Error {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::GeneralError => "GENERAL_ERROR",
                Self::DownloadFailed => "DOWNLOAD_FAILED",
                Self::VerificationFailed => "VERIFICATION_FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "GENERAL_ERROR" => Some(Self::GeneralError),
                "DOWNLOAD_FAILED" => Some(Self::DownloadFailed),
                "VERIFICATION_FAILED" => Some(Self::VerificationFailed),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Seed {
    #[prost(uint32, tag = "1")]
    pub seed: u32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Rollout {
    #[prost(float, tag = "1")]
    pub threshold: f32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Uuid {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AccountData {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub expiry: ::core::option::Option<::prost_types::Timestamp>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AccountHistory {
    #[prost(message, optional, tag = "1")]
    pub number: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VoucherSubmission {
    #[prost(uint64, tag = "1")]
    pub seconds_added: u64,
    #[prost(message, optional, tag = "2")]
    pub new_expiry: ::core::option::Option<::prost_types::Timestamp>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ErrorState {
    #[prost(enumeration = "error_state::Cause", tag = "1")]
    pub cause: i32,
    #[prost(message, optional, tag = "2")]
    pub blocking_error: ::core::option::Option<error_state::FirewallPolicyError>,
    /// AUTH_FAILED
    #[prost(enumeration = "error_state::AuthFailedError", tag = "3")]
    pub auth_failed_error: i32,
    /// TUNNEL_PARAMETER_ERROR
    #[prost(enumeration = "error_state::GenerationError", tag = "4")]
    pub parameter_error: i32,
    /// SET_FIREWALL_POLICY_ERROR
    #[prost(message, optional, tag = "5")]
    pub policy_error: ::core::option::Option<error_state::FirewallPolicyError>,
    /// CREATE_TUNNEL_DEVICE
    #[prost(int32, optional, tag = "6")]
    pub create_tunnel_error: ::core::option::Option<i32>,
    /// Android only
    #[prost(message, optional, tag = "8")]
    pub other_always_on_app_error: ::core::option::Option<
        error_state::OtherAlwaysOnAppError,
    >,
    /// Android only
    #[prost(message, optional, tag = "9")]
    pub invalid_dns_servers_error: ::core::option::Option<
        error_state::InvalidDnsServersError,
    >,
    /// Android only
    #[prost(message, optional, tag = "10")]
    pub invalid_ipv6_config_error: ::core::option::Option<
        error_state::InvalidIpv6Config,
    >,
}
/// Nested message and enum types in `ErrorState`.
pub mod error_state {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct FirewallPolicyError {
        #[prost(enumeration = "firewall_policy_error::ErrorType", tag = "1")]
        pub r#type: i32,
        /// LOCKED
        #[prost(uint32, tag = "2")]
        pub lock_pid: u32,
        #[prost(string, optional, tag = "3")]
        pub lock_name: ::core::option::Option<::prost::alloc::string::String>,
    }
    /// Nested message and enum types in `FirewallPolicyError`.
    pub mod firewall_policy_error {
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ErrorType {
            Generic = 0,
            Locked = 1,
        }
        impl ErrorType {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Generic => "GENERIC",
                    Self::Locked => "LOCKED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "GENERIC" => Some(Self::Generic),
                    "LOCKED" => Some(Self::Locked),
                    _ => None,
                }
            }
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct OtherAlwaysOnAppError {
        #[prost(string, tag = "1")]
        pub app_name: ::prost::alloc::string::String,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct InvalidDnsServersError {
        #[prost(string, repeated, tag = "1")]
        pub ip_addrs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct InvalidIpv6Config {
        #[prost(string, repeated, tag = "1")]
        pub addrs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(string, repeated, tag = "2")]
        pub routes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(string, repeated, tag = "3")]
        pub dns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Cause {
        AuthFailed = 0,
        Ipv6Unavailable = 1,
        SetFirewallPolicyError = 2,
        SetDnsError = 3,
        StartTunnelError = 4,
        CreateTunnelDevice = 5,
        TunnelParameterError = 6,
        IsOffline = 7,
        /// Android only
        NotPrepared = 8,
        /// Android only
        OtherAlwaysOnApp = 9,
        /// Android only
        OtherLegacyAlwaysOnVpn = 10,
        /// Android only
        InvalidDnsServers = 11,
        /// Android only
        InvalidIpv6Config = 14,
        SplitTunnelError = 12,
        NeedFullDiskPermissions = 13,
    }
    impl Cause {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::AuthFailed => "AUTH_FAILED",
                Self::Ipv6Unavailable => "IPV6_UNAVAILABLE",
                Self::SetFirewallPolicyError => "SET_FIREWALL_POLICY_ERROR",
                Self::SetDnsError => "SET_DNS_ERROR",
                Self::StartTunnelError => "START_TUNNEL_ERROR",
                Self::CreateTunnelDevice => "CREATE_TUNNEL_DEVICE",
                Self::TunnelParameterError => "TUNNEL_PARAMETER_ERROR",
                Self::IsOffline => "IS_OFFLINE",
                Self::NotPrepared => "NOT_PREPARED",
                Self::OtherAlwaysOnApp => "OTHER_ALWAYS_ON_APP",
                Self::OtherLegacyAlwaysOnVpn => "OTHER_LEGACY_ALWAYS_ON_VPN",
                Self::InvalidDnsServers => "INVALID_DNS_SERVERS",
                Self::InvalidIpv6Config => "INVALID_IPV6_CONFIG",
                Self::SplitTunnelError => "SPLIT_TUNNEL_ERROR",
                Self::NeedFullDiskPermissions => "NEED_FULL_DISK_PERMISSIONS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AUTH_FAILED" => Some(Self::AuthFailed),
                "IPV6_UNAVAILABLE" => Some(Self::Ipv6Unavailable),
                "SET_FIREWALL_POLICY_ERROR" => Some(Self::SetFirewallPolicyError),
                "SET_DNS_ERROR" => Some(Self::SetDnsError),
                "START_TUNNEL_ERROR" => Some(Self::StartTunnelError),
                "CREATE_TUNNEL_DEVICE" => Some(Self::CreateTunnelDevice),
                "TUNNEL_PARAMETER_ERROR" => Some(Self::TunnelParameterError),
                "IS_OFFLINE" => Some(Self::IsOffline),
                "NOT_PREPARED" => Some(Self::NotPrepared),
                "OTHER_ALWAYS_ON_APP" => Some(Self::OtherAlwaysOnApp),
                "OTHER_LEGACY_ALWAYS_ON_VPN" => Some(Self::OtherLegacyAlwaysOnVpn),
                "INVALID_DNS_SERVERS" => Some(Self::InvalidDnsServers),
                "INVALID_IPV6_CONFIG" => Some(Self::InvalidIpv6Config),
                "SPLIT_TUNNEL_ERROR" => Some(Self::SplitTunnelError),
                "NEED_FULL_DISK_PERMISSIONS" => Some(Self::NeedFullDiskPermissions),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AuthFailedError {
        Unknown = 0,
        InvalidAccount = 1,
        ExpiredAccount = 2,
        TooManyConnections = 3,
    }
    impl AuthFailedError {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "UNKNOWN",
                Self::InvalidAccount => "INVALID_ACCOUNT",
                Self::ExpiredAccount => "EXPIRED_ACCOUNT",
                Self::TooManyConnections => "TOO_MANY_CONNECTIONS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "INVALID_ACCOUNT" => Some(Self::InvalidAccount),
                "EXPIRED_ACCOUNT" => Some(Self::ExpiredAccount),
                "TOO_MANY_CONNECTIONS" => Some(Self::TooManyConnections),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum GenerationError {
        NoMatchingRelayEntry = 0,
        NoMatchingRelayExit = 1,
        NoMatchingRelay = 2,
        NoMatchingBridgeRelay = 3,
        CustomTunnelHostResolutionError = 4,
        NetworkIpv4Unavailable = 5,
        NetworkIpv6Unavailable = 6,
    }
    impl GenerationError {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::NoMatchingRelayEntry => "NO_MATCHING_RELAY_ENTRY",
                Self::NoMatchingRelayExit => "NO_MATCHING_RELAY_EXIT",
                Self::NoMatchingRelay => "NO_MATCHING_RELAY",
                Self::NoMatchingBridgeRelay => "NO_MATCHING_BRIDGE_RELAY",
                Self::CustomTunnelHostResolutionError => {
                    "CUSTOM_TUNNEL_HOST_RESOLUTION_ERROR"
                }
                Self::NetworkIpv4Unavailable => "NETWORK_IPV4_UNAVAILABLE",
                Self::NetworkIpv6Unavailable => "NETWORK_IPV6_UNAVAILABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NO_MATCHING_RELAY_ENTRY" => Some(Self::NoMatchingRelayEntry),
                "NO_MATCHING_RELAY_EXIT" => Some(Self::NoMatchingRelayExit),
                "NO_MATCHING_RELAY" => Some(Self::NoMatchingRelay),
                "NO_MATCHING_BRIDGE_RELAY" => Some(Self::NoMatchingBridgeRelay),
                "CUSTOM_TUNNEL_HOST_RESOLUTION_ERROR" => {
                    Some(Self::CustomTunnelHostResolutionError)
                }
                "NETWORK_IPV4_UNAVAILABLE" => Some(Self::NetworkIpv4Unavailable),
                "NETWORK_IPV6_UNAVAILABLE" => Some(Self::NetworkIpv6Unavailable),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TunnelState {
    #[prost(oneof = "tunnel_state::State", tags = "1, 2, 3, 4, 5")]
    pub state: ::core::option::Option<tunnel_state::State>,
}
/// Nested message and enum types in `TunnelState`.
pub mod tunnel_state {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Disconnected {
        #[prost(message, optional, tag = "1")]
        pub disconnected_location: ::core::option::Option<super::GeoIpLocation>,
        #[prost(bool, tag = "2")]
        pub locked_down: bool,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Connecting {
        #[prost(message, optional, tag = "1")]
        pub relay_info: ::core::option::Option<super::TunnelStateRelayInfo>,
        #[prost(message, optional, tag = "2")]
        pub feature_indicators: ::core::option::Option<super::FeatureIndicators>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Connected {
        #[prost(message, optional, tag = "1")]
        pub relay_info: ::core::option::Option<super::TunnelStateRelayInfo>,
        #[prost(message, optional, tag = "2")]
        pub feature_indicators: ::core::option::Option<super::FeatureIndicators>,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Disconnecting {
        #[prost(enumeration = "super::AfterDisconnect", tag = "1")]
        pub after_disconnect: i32,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Error {
        #[prost(message, optional, tag = "1")]
        pub error_state: ::core::option::Option<super::ErrorState>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum State {
        #[prost(message, tag = "1")]
        Disconnected(Disconnected),
        #[prost(message, tag = "2")]
        Connecting(Connecting),
        #[prost(message, tag = "3")]
        Connected(Connected),
        #[prost(message, tag = "4")]
        Disconnecting(Disconnecting),
        #[prost(message, tag = "5")]
        Error(Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TunnelStateRelayInfo {
    #[prost(message, optional, tag = "1")]
    pub tunnel_endpoint: ::core::option::Option<TunnelEndpoint>,
    #[prost(message, optional, tag = "2")]
    pub location: ::core::option::Option<GeoIpLocation>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TunnelEndpoint {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(enumeration = "TransportProtocol", tag = "2")]
    pub protocol: i32,
    #[prost(bool, tag = "3")]
    pub quantum_resistant: bool,
    #[prost(message, optional, tag = "4")]
    pub obfuscation: ::core::option::Option<ObfuscationInfo>,
    #[prost(message, optional, tag = "5")]
    pub entry_endpoint: ::core::option::Option<Endpoint>,
    #[prost(message, optional, tag = "6")]
    pub tunnel_metadata: ::core::option::Option<TunnelMetadata>,
    #[prost(bool, tag = "7")]
    pub daita: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FeatureIndicators {
    #[prost(enumeration = "FeatureIndicator", repeated, tag = "1")]
    pub active_features: ::prost::alloc::vec::Vec<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ObfuscationInfo {
    #[prost(oneof = "obfuscation_info::Type", tags = "1, 2")]
    pub r#type: ::core::option::Option<obfuscation_info::Type>,
}
/// Nested message and enum types in `ObfuscationInfo`.
pub mod obfuscation_info {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        #[prost(message, tag = "1")]
        Single(super::ObfuscationEndpoint),
        #[prost(message, tag = "2")]
        Multiple(super::MultiplexObfuscation),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MultiplexObfuscation {
    /// optional direct endpoint
    #[prost(message, optional, tag = "1")]
    pub direct: ::core::option::Option<Endpoint>,
    #[prost(message, repeated, tag = "2")]
    pub obfuscators: ::prost::alloc::vec::Vec<ObfuscationEndpoint>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ObfuscationEndpoint {
    #[prost(message, optional, tag = "1")]
    pub endpoint: ::core::option::Option<Endpoint>,
    #[prost(enumeration = "obfuscation_endpoint::ObfuscationType", tag = "2")]
    pub obfuscation_type: i32,
}
/// Nested message and enum types in `ObfuscationEndpoint`.
pub mod obfuscation_endpoint {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ObfuscationType {
        Udp2tcp = 0,
        Shadowsocks = 1,
        Quic = 2,
        Lwo = 3,
    }
    impl ObfuscationType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Udp2tcp => "UDP2TCP",
                Self::Shadowsocks => "SHADOWSOCKS",
                Self::Quic => "QUIC",
                Self::Lwo => "LWO",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UDP2TCP" => Some(Self::Udp2tcp),
                "SHADOWSOCKS" => Some(Self::Shadowsocks),
                "QUIC" => Some(Self::Quic),
                "LWO" => Some(Self::Lwo),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Endpoint {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(enumeration = "TransportProtocol", tag = "2")]
    pub protocol: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GeoIpLocation {
    #[prost(string, optional, tag = "1")]
    pub ipv4: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "2")]
    pub ipv6: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "3")]
    pub country: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "4")]
    pub city: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(double, tag = "5")]
    pub latitude: f64,
    #[prost(double, tag = "6")]
    pub longitude: f64,
    #[prost(bool, tag = "7")]
    pub mullvad_exit_ip: bool,
    #[prost(string, optional, tag = "8")]
    pub hostname: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "10")]
    pub entry_hostname: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TunnelMetadata {
    #[prost(string, tag = "1")]
    pub tunnel_interface: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LocationConstraint {
    /// When a LocationConstraint is constructed, the inner `type` value MUST NOT be null.
    #[prost(oneof = "location_constraint::Type", tags = "1, 2")]
    pub r#type: ::core::option::Option<location_constraint::Type>,
}
/// Nested message and enum types in `LocationConstraint`.
pub mod location_constraint {
    /// When a LocationConstraint is constructed, the inner `type` value MUST NOT be null.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Type {
        #[prost(string, tag = "1")]
        CustomList(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Location(super::GeographicLocationConstraint),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GeographicLocationConstraint {
    #[prost(string, tag = "1")]
    pub country: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub city: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub hostname: ::core::option::Option<::prost::alloc::string::String>,
}
/// TODO: Rename to "CensorshipCircumventionSettings"?
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ObfuscationSettings {
    #[prost(enumeration = "obfuscation_settings::SelectedObfuscation", tag = "1")]
    pub selected_obfuscation: i32,
    #[prost(message, optional, tag = "2")]
    pub udp2tcp: ::core::option::Option<obfuscation_settings::Udp2TcpObfuscation>,
    #[prost(message, optional, tag = "3")]
    pub shadowsocks: ::core::option::Option<obfuscation_settings::Shadowsocks>,
    #[prost(message, optional, tag = "4")]
    pub wireguard_port: ::core::option::Option<obfuscation_settings::WireguardPort>,
    #[prost(message, optional, tag = "5")]
    pub lwo: ::core::option::Option<obfuscation_settings::Lwo>,
}
/// Nested message and enum types in `ObfuscationSettings`.
pub mod obfuscation_settings {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Udp2TcpObfuscation {
        #[prost(uint32, optional, tag = "1")]
        pub port: ::core::option::Option<u32>,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Shadowsocks {
        #[prost(uint32, optional, tag = "1")]
        pub port: ::core::option::Option<u32>,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WireguardPort {
        #[prost(uint32, optional, tag = "1")]
        pub port: ::core::option::Option<u32>,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Lwo {
        #[prost(uint32, optional, tag = "1")]
        pub port: ::core::option::Option<u32>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SelectedObfuscation {
        Auto = 0,
        Off = 1,
        WireguardPort = 2,
        Udp2tcp = 3,
        Shadowsocks = 4,
        Quic = 5,
        Lwo = 6,
    }
    impl SelectedObfuscation {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Auto => "AUTO",
                Self::Off => "OFF",
                Self::WireguardPort => "WIREGUARD_PORT",
                Self::Udp2tcp => "UDP2TCP",
                Self::Shadowsocks => "SHADOWSOCKS",
                Self::Quic => "QUIC",
                Self::Lwo => "LWO",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AUTO" => Some(Self::Auto),
                "OFF" => Some(Self::Off),
                "WIREGUARD_PORT" => Some(Self::WireguardPort),
                "UDP2TCP" => Some(Self::Udp2tcp),
                "SHADOWSOCKS" => Some(Self::Shadowsocks),
                "QUIC" => Some(Self::Quic),
                "LWO" => Some(Self::Lwo),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomList {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub locations: ::prost::alloc::vec::Vec<GeographicLocationConstraint>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NewCustomList {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub locations: ::prost::alloc::vec::Vec<GeographicLocationConstraint>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomListSettings {
    #[prost(message, repeated, tag = "1")]
    pub custom_lists: ::prost::alloc::vec::Vec<CustomList>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Socks5Local {
    #[prost(string, tag = "1")]
    pub remote_ip: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub remote_port: u32,
    #[prost(enumeration = "TransportProtocol", tag = "3")]
    pub remote_transport_protocol: i32,
    #[prost(uint32, tag = "4")]
    pub local_port: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SocksAuth {
    #[prost(string, tag = "1")]
    pub username: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub password: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Socks5Remote {
    #[prost(string, tag = "1")]
    pub ip: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub port: u32,
    #[prost(message, optional, tag = "3")]
    pub auth: ::core::option::Option<SocksAuth>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Shadowsocks {
    #[prost(string, tag = "1")]
    pub ip: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub port: u32,
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub cipher: ::core::option::Option<shadowsocks::Cipher>,
}
/// Nested message and enum types in `Shadowsocks`.
pub mod shadowsocks {
    /// A Shadowsocks cipher.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Cipher {
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
    }
    /// All supported Shadowsocks ciphers.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Ciphers {
        #[prost(message, repeated, tag = "1")]
        pub ciphers: ::prost::alloc::vec::Vec<Cipher>,
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CustomProxy {
    #[prost(oneof = "custom_proxy::ProxyMethod", tags = "1, 2, 3")]
    pub proxy_method: ::core::option::Option<custom_proxy::ProxyMethod>,
}
/// Nested message and enum types in `CustomProxy`.
pub mod custom_proxy {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ProxyMethod {
        #[prost(message, tag = "1")]
        Socks5local(super::Socks5Local),
        #[prost(message, tag = "2")]
        Socks5remote(super::Socks5Remote),
        #[prost(message, tag = "3")]
        Shadowsocks(super::Shadowsocks),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AccessMethod {
    /// message DomainFronting {}
    #[prost(oneof = "access_method::AccessMethod", tags = "1, 2, 3, 4")]
    pub access_method: ::core::option::Option<access_method::AccessMethod>,
}
/// Nested message and enum types in `AccessMethod`.
pub mod access_method {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Direct {}
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Bridges {}
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EncryptedDnsProxy {}
    /// message DomainFronting {}
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum AccessMethod {
        #[prost(message, tag = "1")]
        Direct(Direct),
        #[prost(message, tag = "2")]
        Bridges(Bridges),
        #[prost(message, tag = "3")]
        EncryptedDnsProxy(EncryptedDnsProxy),
        /// DomainFronting domain_fronting = 5;
        #[prost(message, tag = "4")]
        Custom(super::CustomProxy),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AccessMethodSetting {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<Uuid>,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub enabled: bool,
    #[prost(message, optional, tag = "4")]
    pub access_method: ::core::option::Option<AccessMethod>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NewAccessMethodSetting {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub enabled: bool,
    #[prost(message, optional, tag = "3")]
    pub access_method: ::core::option::Option<AccessMethod>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApiAccessMethodSettings {
    #[prost(message, optional, tag = "1")]
    pub direct: ::core::option::Option<AccessMethodSetting>,
    #[prost(message, optional, tag = "2")]
    pub mullvad_bridges: ::core::option::Option<AccessMethodSetting>,
    #[prost(message, optional, tag = "3")]
    pub encrypted_dns_proxy: ::core::option::Option<AccessMethodSetting>,
    /// AccessMethodSetting domain_fronting = 5;
    #[prost(message, repeated, tag = "4")]
    pub custom: ::prost::alloc::vec::Vec<AccessMethodSetting>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Settings {
    #[prost(message, optional, tag = "1")]
    pub relay_settings: ::core::option::Option<RelaySettings>,
    #[prost(bool, tag = "3")]
    pub allow_lan: bool,
    #[prost(bool, tag = "4")]
    pub lockdown_mode: bool,
    #[prost(bool, tag = "5")]
    pub auto_connect: bool,
    #[prost(message, optional, tag = "6")]
    pub tunnel_options: ::core::option::Option<TunnelOptions>,
    #[prost(bool, tag = "7")]
    pub show_beta_releases: bool,
    #[prost(message, optional, tag = "8")]
    pub split_tunnel: ::core::option::Option<SplitTunnelSettings>,
    #[prost(message, optional, tag = "9")]
    pub obfuscation_settings: ::core::option::Option<ObfuscationSettings>,
    #[prost(message, optional, tag = "10")]
    pub custom_lists: ::core::option::Option<CustomListSettings>,
    #[prost(message, optional, tag = "11")]
    pub api_access_methods: ::core::option::Option<ApiAccessMethodSettings>,
    #[prost(message, repeated, tag = "12")]
    pub relay_overrides: ::prost::alloc::vec::Vec<RelayOverride>,
    #[prost(message, optional, tag = "13")]
    pub recents: ::core::option::Option<Recents>,
    #[prost(bool, tag = "14")]
    pub update_default_location: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelayOverride {
    #[prost(string, tag = "1")]
    pub hostname: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "2")]
    pub ipv4_addr_in: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub ipv6_addr_in: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Recents {
    #[prost(message, repeated, tag = "1")]
    pub recents: ::prost::alloc::vec::Vec<Recent>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MultihopRecent {
    #[prost(message, optional, tag = "1")]
    pub entry: ::core::option::Option<LocationConstraint>,
    #[prost(message, optional, tag = "2")]
    pub exit: ::core::option::Option<LocationConstraint>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Recent {
    #[prost(oneof = "recent::Type", tags = "1, 2")]
    pub r#type: ::core::option::Option<recent::Type>,
}
/// Nested message and enum types in `Recent`.
pub mod recent {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Type {
        #[prost(message, tag = "1")]
        Singlehop(super::LocationConstraint),
        #[prost(message, tag = "2")]
        Multihop(super::MultihopRecent),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SplitTunnelSettings {
    #[prost(bool, tag = "1")]
    pub enable_exclusions: bool,
    #[prost(string, repeated, tag = "2")]
    pub apps: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RelaySettings {
    #[prost(oneof = "relay_settings::Endpoint", tags = "1, 2")]
    pub endpoint: ::core::option::Option<relay_settings::Endpoint>,
}
/// Nested message and enum types in `RelaySettings`.
pub mod relay_settings {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Endpoint {
        #[prost(message, tag = "1")]
        Custom(super::CustomRelaySettings),
        #[prost(message, tag = "2")]
        Normal(super::NormalRelaySettings),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NormalRelaySettings {
    #[prost(message, optional, tag = "1")]
    pub location: ::core::option::Option<LocationConstraint>,
    #[prost(string, repeated, tag = "2")]
    pub providers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub wireguard_constraints: ::core::option::Option<WireguardConstraints>,
    #[prost(enumeration = "Ownership", tag = "5")]
    pub ownership: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TransportPort {
    #[prost(enumeration = "TransportProtocol", tag = "1")]
    pub protocol: i32,
    #[prost(uint32, optional, tag = "2")]
    pub port: ::core::option::Option<u32>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WireguardConstraints {
    #[prost(enumeration = "IpVersion", optional, tag = "2")]
    pub ip_version: ::core::option::Option<i32>,
    #[prost(string, repeated, tag = "3")]
    pub allowed_ips: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(bool, tag = "4")]
    pub use_multihop: bool,
    #[prost(message, optional, tag = "5")]
    pub entry_location: ::core::option::Option<LocationConstraint>,
    #[prost(string, repeated, tag = "6")]
    pub entry_providers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(enumeration = "Ownership", tag = "7")]
    pub entry_ownership: i32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CustomRelaySettings {
    #[prost(string, tag = "1")]
    pub host: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<WireguardConfig>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WireguardConfig {
    #[prost(message, optional, tag = "1")]
    pub tunnel: ::core::option::Option<wireguard_config::TunnelConfig>,
    #[prost(message, optional, tag = "2")]
    pub peer: ::core::option::Option<wireguard_config::PeerConfig>,
    #[prost(string, tag = "3")]
    pub ipv4_gateway: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "4")]
    pub ipv6_gateway: ::core::option::Option<::prost::alloc::string::String>,
}
/// Nested message and enum types in `WireguardConfig`.
pub mod wireguard_config {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TunnelConfig {
        #[prost(bytes = "vec", tag = "1")]
        pub private_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(string, repeated, tag = "2")]
        pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PeerConfig {
        #[prost(bytes = "vec", tag = "1")]
        pub public_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(string, repeated, tag = "2")]
        pub allowed_ips: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(string, tag = "3")]
        pub endpoint: ::prost::alloc::string::String,
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QuantumResistantState {
    #[prost(enumeration = "quantum_resistant_state::State", tag = "1")]
    pub state: i32,
}
/// Nested message and enum types in `QuantumResistantState`.
pub mod quantum_resistant_state {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        On = 0,
        Off = 1,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::On => "ON",
                Self::Off => "OFF",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ON" => Some(Self::On),
                "OFF" => Some(Self::Off),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DaitaSettings {
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    #[prost(bool, tag = "2")]
    pub direct_only: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TunnelOptions {
    #[prost(uint32, optional, tag = "1")]
    pub mtu: ::core::option::Option<u32>,
    #[prost(message, optional, tag = "2")]
    pub rotation_interval: ::core::option::Option<::prost_types::Duration>,
    #[prost(message, optional, tag = "3")]
    pub quantum_resistant: ::core::option::Option<QuantumResistantState>,
    #[prost(message, optional, tag = "4")]
    pub daita: ::core::option::Option<DaitaSettings>,
    #[prost(bool, tag = "5")]
    pub enable_ipv6: bool,
    #[prost(message, optional, tag = "6")]
    pub dns_options: ::core::option::Option<DnsOptions>,
    /// Force userspace WireGuard.
    /// This option does not apply to Android or macOS.
    #[prost(bool, tag = "7")]
    pub userspace: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DefaultDnsOptions {
    #[prost(bool, tag = "1")]
    pub block_ads: bool,
    #[prost(bool, tag = "2")]
    pub block_trackers: bool,
    #[prost(bool, tag = "3")]
    pub block_malware: bool,
    #[prost(bool, tag = "4")]
    pub block_adult_content: bool,
    #[prost(bool, tag = "5")]
    pub block_gambling: bool,
    #[prost(bool, tag = "6")]
    pub block_social_media: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CustomDnsOptions {
    #[prost(string, repeated, tag = "1")]
    pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DnsOptions {
    #[prost(enumeration = "dns_options::DnsState", tag = "1")]
    pub state: i32,
    #[prost(message, optional, tag = "2")]
    pub default_options: ::core::option::Option<DefaultDnsOptions>,
    #[prost(message, optional, tag = "3")]
    pub custom_options: ::core::option::Option<CustomDnsOptions>,
}
/// Nested message and enum types in `DnsOptions`.
pub mod dns_options {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DnsState {
        Default = 0,
        Custom = 1,
    }
    impl DnsState {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Default => "DEFAULT",
                Self::Custom => "CUSTOM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DEFAULT" => Some(Self::Default),
                "CUSTOM" => Some(Self::Custom),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PublicKey {
    #[prost(bytes = "vec", tag = "1")]
    pub key: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExcludedProcess {
    #[prost(uint32, tag = "1")]
    pub pid: u32,
    #[prost(string, tag = "2")]
    pub image: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub inherited: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExcludedProcessList {
    #[prost(message, repeated, tag = "1")]
    pub processes: ::prost::alloc::vec::Vec<ExcludedProcess>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SuggestedUpgrade {
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub changelog: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "3")]
    pub verified_installer_path: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppVersionInfo {
    #[prost(bool, tag = "1")]
    pub supported: bool,
    #[prost(message, optional, tag = "2")]
    pub suggested_upgrade: ::core::option::Option<SuggestedUpgrade>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RelayListCountry {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub code: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub cities: ::prost::alloc::vec::Vec<RelayListCity>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RelayListCity {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub code: ::prost::alloc::string::String,
    #[prost(double, tag = "3")]
    pub latitude: f64,
    #[prost(double, tag = "4")]
    pub longitude: f64,
    #[prost(message, repeated, tag = "5")]
    pub relays: ::prost::alloc::vec::Vec<Relay>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Relay {
    #[prost(string, tag = "1")]
    pub hostname: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub ipv4_addr_in: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "3")]
    pub ipv6_addr_in: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "4")]
    pub include_in_country: bool,
    #[prost(bool, tag = "5")]
    pub active: bool,
    #[prost(bool, tag = "6")]
    pub owned: bool,
    #[prost(string, tag = "7")]
    pub provider: ::prost::alloc::string::String,
    #[prost(fixed64, tag = "8")]
    pub weight: u64,
    #[prost(message, optional, tag = "9")]
    pub endpoint_data: ::core::option::Option<relay::WireguardEndpoint>,
    #[prost(message, optional, tag = "10")]
    pub location: ::core::option::Option<Location>,
}
/// Nested message and enum types in `Relay`.
pub mod relay {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WireguardEndpoint {
        #[prost(bytes = "vec", tag = "1")]
        pub public_key: ::prost::alloc::vec::Vec<u8>,
        #[prost(bool, tag = "2")]
        pub daita: bool,
        #[prost(message, optional, tag = "3")]
        pub quic: ::core::option::Option<wireguard_endpoint::Quic>,
        #[prost(string, repeated, tag = "4")]
        pub shadowsocks_extra_addr_in: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        #[prost(bool, tag = "5")]
        pub lwo: bool,
    }
    /// Nested message and enum types in `WireguardEndpoint`.
    pub mod wireguard_endpoint {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Quic {
            #[prost(string, tag = "1")]
            pub domain: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub token: ::prost::alloc::string::String,
            #[prost(string, repeated, tag = "3")]
            pub addr_in: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Location {
    #[prost(string, tag = "1")]
    pub country: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub country_code: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub city: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub city_code: ::prost::alloc::string::String,
    #[prost(double, tag = "5")]
    pub latitude: f64,
    #[prost(double, tag = "6")]
    pub longitude: f64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DaemonEvent {
    #[prost(oneof = "daemon_event::Event", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
    pub event: ::core::option::Option<daemon_event::Event>,
}
/// Nested message and enum types in `DaemonEvent`.
pub mod daemon_event {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Event {
        #[prost(message, tag = "1")]
        TunnelState(super::TunnelState),
        #[prost(message, tag = "2")]
        Settings(super::Settings),
        #[prost(message, tag = "3")]
        RelayList(super::RelayList),
        #[prost(message, tag = "4")]
        VersionInfo(super::AppVersionInfo),
        #[prost(message, tag = "5")]
        Device(super::DeviceEvent),
        #[prost(message, tag = "6")]
        RemoveDevice(super::RemoveDeviceEvent),
        #[prost(message, tag = "7")]
        NewAccessMethod(super::AccessMethodSetting),
        #[prost(message, tag = "8")]
        LeakInfo(super::LeakInfo),
    }
}
/// List of VPN relays
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RelayList {
    #[prost(message, repeated, tag = "1")]
    pub countries: ::prost::alloc::vec::Vec<RelayListCountry>,
    #[prost(message, optional, tag = "2")]
    pub endpoint_data: ::core::option::Option<WireguardEndpointData>,
}
/// List of bridge servers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BridgeList {
    #[prost(message, repeated, tag = "1")]
    pub bridges: ::prost::alloc::vec::Vec<Bridge>,
    #[prost(message, optional, tag = "2")]
    pub endpoint_data: ::core::option::Option<BridgeEndpointData>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Bridge {
    #[prost(string, tag = "1")]
    pub hostname: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub ipv4_addr_in: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "3")]
    pub ipv6_addr_in: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "4")]
    pub active: bool,
    #[prost(fixed64, tag = "5")]
    pub weight: u64,
    #[prost(message, optional, tag = "6")]
    pub location: ::core::option::Option<Location>,
}
/// Shadowsocks endpoints reachable on all bridge servers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BridgeEndpointData {
    #[prost(message, repeated, tag = "1")]
    pub shadowsocks: ::prost::alloc::vec::Vec<ShadowsocksEndpointData>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShadowsocksEndpointData {
    #[prost(uint32, tag = "1")]
    pub port: u32,
    #[prost(string, tag = "2")]
    pub cipher: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    #[prost(enumeration = "TransportProtocol", tag = "4")]
    pub protocol: i32,
}
/// Endpoints reachable on all WireGuard servers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WireguardEndpointData {
    #[prost(message, repeated, tag = "1")]
    pub port_ranges: ::prost::alloc::vec::Vec<PortRange>,
    #[prost(string, tag = "2")]
    pub ipv4_gateway: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub ipv6_gateway: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub shadowsocks_port_ranges: ::prost::alloc::vec::Vec<PortRange>,
    #[prost(uint32, repeated, tag = "5")]
    pub udp2tcp_ports: ::prost::alloc::vec::Vec<u32>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PortRange {
    #[prost(uint32, tag = "1")]
    pub first: u32,
    #[prost(uint32, tag = "2")]
    pub last: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AccountAndDevice {
    #[prost(string, tag = "1")]
    pub account_number: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub device: ::core::option::Option<Device>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Device {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(bytes = "vec", tag = "3")]
    pub pubkey: ::prost::alloc::vec::Vec<u8>,
    #[prost(bool, tag = "5")]
    pub hijack_dns: bool,
    #[prost(message, optional, tag = "6")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeviceList {
    #[prost(message, repeated, tag = "1")]
    pub devices: ::prost::alloc::vec::Vec<Device>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeviceRemoval {
    #[prost(string, tag = "1")]
    pub account_number: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub device_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeviceState {
    #[prost(enumeration = "device_state::State", tag = "1")]
    pub state: i32,
    #[prost(message, optional, tag = "2")]
    pub device: ::core::option::Option<AccountAndDevice>,
}
/// Nested message and enum types in `DeviceState`.
pub mod device_state {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        LoggedIn = 0,
        LoggedOut = 1,
        Revoked = 2,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::LoggedIn => "LOGGED_IN",
                Self::LoggedOut => "LOGGED_OUT",
                Self::Revoked => "REVOKED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LOGGED_IN" => Some(Self::LoggedIn),
                "LOGGED_OUT" => Some(Self::LoggedOut),
                "REVOKED" => Some(Self::Revoked),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeviceEvent {
    #[prost(enumeration = "device_event::Cause", tag = "1")]
    pub cause: i32,
    #[prost(message, optional, tag = "2")]
    pub new_state: ::core::option::Option<DeviceState>,
}
/// Nested message and enum types in `DeviceEvent`.
pub mod device_event {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Cause {
        LoggedIn = 0,
        LoggedOut = 1,
        Revoked = 2,
        Updated = 3,
        RotatedKey = 4,
    }
    impl Cause {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::LoggedIn => "LOGGED_IN",
                Self::LoggedOut => "LOGGED_OUT",
                Self::Revoked => "REVOKED",
                Self::Updated => "UPDATED",
                Self::RotatedKey => "ROTATED_KEY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LOGGED_IN" => Some(Self::LoggedIn),
                "LOGGED_OUT" => Some(Self::LoggedOut),
                "REVOKED" => Some(Self::Revoked),
                "UPDATED" => Some(Self::Updated),
                "ROTATED_KEY" => Some(Self::RotatedKey),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveDeviceEvent {
    #[prost(string, tag = "1")]
    pub account_number: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub new_device_list: ::prost::alloc::vec::Vec<Device>,
}
/// / Details about a potential leak that was detected in the connected state.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LeakInfo {
    /// / IPs that were reachable outside of the tunnel.
    /// /
    /// / Format: A list of IPv4 and IPv6 addresses. Possibly intermingled.
    #[prost(string, repeated, tag = "1")]
    pub ip_addrs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// / The interface which was able to reach the IPs `ip_addrs`.
    /// /
    /// / Format: The name of the leaky interface.
    #[prost(string, tag = "2")]
    pub interface: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlayExternalObfuscatedAccountId {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlayPurchase {
    #[prost(string, tag = "1")]
    pub product_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub purchase_token: ::core::option::Option<PlayPurchasePaymentToken>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlayPurchasePaymentToken {
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AllowedIpsList {
    #[prost(string, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LogFilter {
    #[prost(string, tag = "1")]
    pub log_filter: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LogMessage {
    #[prost(string, tag = "1")]
    pub message: ::prost::alloc::string::String,
}
/// The great multihop migration of 2026
///
/// The migration has to consider the following scenarios:
///
/// | Scenario | Multihop | DAITA | Direct Only | Magic Multihop | Filters |
/// |----------|----------|-------|-------------|----------------|---------|
/// |    1A    |    ❌    |   ❌  |      ❔     |       ❔       |    ❌   |
/// |    1B    |    ❌    |   ❌  |      ❔     |       ❔       |    ✅   |
/// |    2     |    ❌    |   ✅  |      ❌     |       ❔       |    ❌   |
/// |    3A    |    ❌    |   ✅  |      ❌     |       ❌       |    ✅   |
/// |    3A    |    ❌    |   ✅  |      ❌     |       ✅       |    ✅   |
/// |    4A    |    ❌    |   ✅  |      ✅     |       ❔       |    ❌   |
/// |    4B    |    ❌    |   ✅  |      ✅     |       ❔       |    ✅   |
/// |    5A    |    ✅    |   ❌  |      ❔     |       ❔       |    ❌   |
/// |    5B    |    ✅    |   ❌  |      ❔     |       ❔       |    ✅   |
/// |    6A    |    ✅    |   ✅  |      ❌     |       ❔       |    ❌   |
/// |    6B    |    ✅    |   ✅  |      ❌     |       ❔       |    ✅   |
/// |    7A    |    ✅    |   ✅  |      ✅     |       ❔       |    ❌   |
/// |    7B    |    ✅    |   ✅  |      ✅     |       ❔       |    ✅   |
///
/// The legends have the following meaning:
/// - ✅ : The setting was enabled.
/// - ❌ : The setting was disabled.
/// - ❔ : The setting did not contribute to detecting which migration to run ("Scenario").
///
/// Clarification of some settings:
/// - Direct only: DAITA specific setting which prevented Magic Multihop from taking effect.
/// - Magic Multihop: If DAITA was enabled but Direct only was disabled, the relay selector might
///   have chosen an entry relay automatically. If that was the case, Magic Multihop was enabled.
/// - Filters: If any ownership or provider filter was enabled, the Filters box is ticked with ✅.
///
/// # Notes on updated settings post-migration.
///
/// * In the same update as the SplitFilterMigration is run, the Multihop setting transitions from
///   being a boolean state (on/off) to now being a tri-state:
///
/// - Always
/// - When needed
/// - Never
///
/// * If any filters were previously set, they were copied and applied as both entry + exit filters.
///
/// * "Daita: Direct only" does not exist anymore. If Daita was turned off, it is still off.
///   Otherwise Daita is enabled.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SplitFilterMigration {
    #[prost(enumeration = "split_filter_migration::Scenario", tag = "1")]
    pub scenario: i32,
}
/// Nested message and enum types in `SplitFilterMigration`.
pub mod split_filter_migration {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Scenario {
        /// 1A
        OneA = 0,
        /// 1B
        OneB = 1,
        /// 2
        Two = 2,
        /// 3A
        ThreeA = 3,
        /// 3B
        ThreeB = 4,
        /// 4A
        FourA = 5,
        /// 4B
        FourB = 6,
        /// 5A
        FiveA = 7,
        /// 5B
        FiveB = 8,
        /// 6A
        SixA = 9,
        /// 6B
        SixB = 10,
        /// 7A
        SevenA = 11,
        /// 7B
        SevenB = 12,
    }
    impl Scenario {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::OneA => "OneA",
                Self::OneB => "OneB",
                Self::Two => "Two",
                Self::ThreeA => "ThreeA",
                Self::ThreeB => "ThreeB",
                Self::FourA => "FourA",
                Self::FourB => "FourB",
                Self::FiveA => "FiveA",
                Self::FiveB => "FiveB",
                Self::SixA => "SixA",
                Self::SixB => "SixB",
                Self::SevenA => "SevenA",
                Self::SevenB => "SevenB",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OneA" => Some(Self::OneA),
                "OneB" => Some(Self::OneB),
                "Two" => Some(Self::Two),
                "ThreeA" => Some(Self::ThreeA),
                "ThreeB" => Some(Self::ThreeB),
                "FourA" => Some(Self::FourA),
                "FourB" => Some(Self::FourB),
                "FiveA" => Some(Self::FiveA),
                "FiveB" => Some(Self::FiveB),
                "SixA" => Some(Self::SixA),
                "SixB" => Some(Self::SixB),
                "SevenA" => Some(Self::SevenA),
                "SevenB" => Some(Self::SevenB),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AfterDisconnect {
    Nothing = 0,
    Block = 1,
    Reconnect = 2,
}
impl AfterDisconnect {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Nothing => "NOTHING",
            Self::Block => "BLOCK",
            Self::Reconnect => "RECONNECT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NOTHING" => Some(Self::Nothing),
            "BLOCK" => Some(Self::Block),
            "RECONNECT" => Some(Self::Reconnect),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FeatureIndicator {
    QuantumResistance = 0,
    Multihop = 1,
    SplitTunneling = 2,
    LockdownMode = 3,
    WireguardPort = 4,
    Udp2Tcp = 5,
    Shadowsocks = 6,
    Quic = 7,
    Lwo = 8,
    LanSharing = 9,
    DnsContentBlockers = 10,
    CustomDns = 11,
    ServerIpOverride = 12,
    CustomMtu = 13,
    Daita = 14,
    DaitaMultihop = 15,
}
impl FeatureIndicator {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::QuantumResistance => "QUANTUM_RESISTANCE",
            Self::Multihop => "MULTIHOP",
            Self::SplitTunneling => "SPLIT_TUNNELING",
            Self::LockdownMode => "LOCKDOWN_MODE",
            Self::WireguardPort => "WIREGUARD_PORT",
            Self::Udp2Tcp => "UDP_2_TCP",
            Self::Shadowsocks => "SHADOWSOCKS",
            Self::Quic => "QUIC",
            Self::Lwo => "LWO",
            Self::LanSharing => "LAN_SHARING",
            Self::DnsContentBlockers => "DNS_CONTENT_BLOCKERS",
            Self::CustomDns => "CUSTOM_DNS",
            Self::ServerIpOverride => "SERVER_IP_OVERRIDE",
            Self::CustomMtu => "CUSTOM_MTU",
            Self::Daita => "DAITA",
            Self::DaitaMultihop => "DAITA_MULTIHOP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "QUANTUM_RESISTANCE" => Some(Self::QuantumResistance),
            "MULTIHOP" => Some(Self::Multihop),
            "SPLIT_TUNNELING" => Some(Self::SplitTunneling),
            "LOCKDOWN_MODE" => Some(Self::LockdownMode),
            "WIREGUARD_PORT" => Some(Self::WireguardPort),
            "UDP_2_TCP" => Some(Self::Udp2Tcp),
            "SHADOWSOCKS" => Some(Self::Shadowsocks),
            "QUIC" => Some(Self::Quic),
            "LWO" => Some(Self::Lwo),
            "LAN_SHARING" => Some(Self::LanSharing),
            "DNS_CONTENT_BLOCKERS" => Some(Self::DnsContentBlockers),
            "CUSTOM_DNS" => Some(Self::CustomDns),
            "SERVER_IP_OVERRIDE" => Some(Self::ServerIpOverride),
            "CUSTOM_MTU" => Some(Self::CustomMtu),
            "DAITA" => Some(Self::Daita),
            "DAITA_MULTIHOP" => Some(Self::DaitaMultihop),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Ownership {
    Any = 0,
    MullvadOwned = 1,
    Rented = 2,
}
impl Ownership {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Any => "ANY",
            Self::MullvadOwned => "MULLVAD_OWNED",
            Self::Rented => "RENTED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ANY" => Some(Self::Any),
            "MULLVAD_OWNED" => Some(Self::MullvadOwned),
            "RENTED" => Some(Self::Rented),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IpVersion {
    V4 = 0,
    V6 = 1,
}
impl IpVersion {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::V4 => "V4",
            Self::V6 => "V6",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "V4" => Some(Self::V4),
            "V6" => Some(Self::V6),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TransportProtocol {
    Udp = 0,
    Tcp = 1,
}
impl TransportProtocol {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Udp => "UDP",
            Self::Tcp => "TCP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UDP" => Some(Self::Udp),
            "TCP" => Some(Self::Tcp),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod management_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct ManagementServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ManagementServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ManagementServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ManagementServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ManagementServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Control and get tunnel state
        pub async fn connect_tunnel(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ConnectTunnel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ConnectTunnel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn disconnect_tunnel(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/DisconnectTunnel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "DisconnectTunnel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn reconnect_tunnel(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ReconnectTunnel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ReconnectTunnel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_tunnel_state(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::TunnelState>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetTunnelState",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetTunnelState",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Control the daemon and receive events
        pub async fn events_listen(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::DaemonEvent>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/EventsListen",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "EventsListen",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// DEPRECATED: Prefer PrepareRestartV2.
        pub async fn prepare_restart(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/PrepareRestart",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "PrepareRestart",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Takes a a boolean argument which says whether the daemon should stop after
        /// it is done preparing for a restart.
        pub async fn prepare_restart_v2(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/PrepareRestartV2",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "PrepareRestartV2",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn factory_reset(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/FactoryReset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "FactoryReset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_current_version(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetCurrentVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetCurrentVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get information about the latest available version of the app.
        /// Note that calling this during an in-app upgrade will cancel the upgrade.
        pub async fn get_version_info(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::AppVersionInfo>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetVersionInfo",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetVersionInfo",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn is_performing_post_upgrade(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/IsPerformingPostUpgrade",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "IsPerformingPostUpgrade",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Relays and tunnel constraints
        pub async fn update_relay_locations(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/UpdateRelayLocations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "UpdateRelayLocations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_relay_locations(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::RelayList>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetRelayLocations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetRelayLocations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_relay_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::RelaySettings>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetRelaySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetRelaySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_obfuscation_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::ObfuscationSettings>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetObfuscationSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetObfuscationSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Settings
        pub async fn get_settings(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::Settings>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn reset_settings(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ResetSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ResetSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_allow_lan(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetAllowLan",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetAllowLan",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_show_beta_releases(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetShowBetaReleases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetShowBetaReleases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_lockdown_mode(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetLockdownMode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetLockdownMode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_auto_connect(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetAutoConnect",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetAutoConnect",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_wireguard_mtu(
            &mut self,
            request: impl tonic::IntoRequest<u32>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetWireguardMtu",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetWireguardMtu",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_wireguard_allowed_ips(
            &mut self,
            request: impl tonic::IntoRequest<super::AllowedIpsList>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetWireguardAllowedIps",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetWireguardAllowedIps",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_enable_ipv6(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetEnableIpv6",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetEnableIpv6",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_quantum_resistant_tunnel(
            &mut self,
            request: impl tonic::IntoRequest<super::QuantumResistantState>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetQuantumResistantTunnel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetQuantumResistantTunnel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_enable_daita(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetEnableDaita",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetEnableDaita",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_daita_direct_only(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetDaitaDirectOnly",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetDaitaDirectOnly",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_daita_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::DaitaSettings>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetDaitaSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetDaitaSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_dns_options(
            &mut self,
            request: impl tonic::IntoRequest<super::DnsOptions>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetDnsOptions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetDnsOptions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_relay_override(
            &mut self,
            request: impl tonic::IntoRequest<super::RelayOverride>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetRelayOverride",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetRelayOverride",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn clear_all_relay_overrides(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearAllRelayOverrides",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearAllRelayOverrides",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_enable_recents(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetEnableRecents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetEnableRecents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_userspace_wireguard(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetUserspaceWireguard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetUserspaceWireguard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Account management
        pub async fn create_new_account(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/CreateNewAccount",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "CreateNewAccount",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn login_account(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/LoginAccount",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "LoginAccount",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn logout_account(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/LogoutAccount",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "LogoutAccount",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_account_data(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<super::AccountData>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetAccountData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetAccountData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_account_history(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::AccountHistory>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetAccountHistory",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetAccountHistory",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn clear_account_history(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearAccountHistory",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearAccountHistory",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_www_auth_token(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetWwwAuthToken",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetWwwAuthToken",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn submit_voucher(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<
            tonic::Response<super::VoucherSubmission>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SubmitVoucher",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SubmitVoucher",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Android only
        pub async fn delete_account(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/DeleteAccount",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "DeleteAccount",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Device management
        pub async fn get_device(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::DeviceState>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetDevice",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetDevice",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_device(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/UpdateDevice",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "UpdateDevice",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_devices(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<super::DeviceList>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ListDevices",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ListDevices",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn remove_device(
            &mut self,
            request: impl tonic::IntoRequest<super::DeviceRemoval>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/RemoveDevice",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "RemoveDevice",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// WireGuard key management
        pub async fn set_wireguard_rotation_interval(
            &mut self,
            request: impl tonic::IntoRequest<::prost_types::Duration>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetWireguardRotationInterval",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetWireguardRotationInterval",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn reset_wireguard_rotation_interval(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ResetWireguardRotationInterval",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ResetWireguardRotationInterval",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn rotate_wireguard_key(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/RotateWireguardKey",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "RotateWireguardKey",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_wireguard_key(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::PublicKey>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetWireguardKey",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetWireguardKey",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Custom lists
        pub async fn create_custom_list(
            &mut self,
            request: impl tonic::IntoRequest<super::NewCustomList>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/CreateCustomList",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "CreateCustomList",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_custom_list(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/DeleteCustomList",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "DeleteCustomList",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_custom_list(
            &mut self,
            request: impl tonic::IntoRequest<super::CustomList>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/UpdateCustomList",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "UpdateCustomList",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn clear_custom_lists(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearCustomLists",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearCustomLists",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Access methods
        pub async fn add_api_access_method(
            &mut self,
            request: impl tonic::IntoRequest<super::NewAccessMethodSetting>,
        ) -> std::result::Result<tonic::Response<super::Uuid>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/AddApiAccessMethod",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "AddApiAccessMethod",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn remove_api_access_method(
            &mut self,
            request: impl tonic::IntoRequest<super::Uuid>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/RemoveApiAccessMethod",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "RemoveApiAccessMethod",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_api_access_method(
            &mut self,
            request: impl tonic::IntoRequest<super::Uuid>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetApiAccessMethod",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetApiAccessMethod",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_api_access_method(
            &mut self,
            request: impl tonic::IntoRequest<super::AccessMethodSetting>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/UpdateApiAccessMethod",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "UpdateApiAccessMethod",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn clear_custom_api_access_methods(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearCustomApiAccessMethods",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearCustomApiAccessMethods",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_current_api_access_method(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::AccessMethodSetting>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetCurrentApiAccessMethod",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetCurrentApiAccessMethod",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn test_custom_api_access_method(
            &mut self,
            request: impl tonic::IntoRequest<super::CustomProxy>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/TestCustomApiAccessMethod",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "TestCustomApiAccessMethod",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn test_api_access_method_by_id(
            &mut self,
            request: impl tonic::IntoRequest<super::Uuid>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/TestApiAccessMethodById",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "TestApiAccessMethodById",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Enumerate all supported Shadowsocks ciphers.
        pub async fn shadowsocks_ciphers(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::shadowsocks::Ciphers>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ShadowsocksCiphers",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ShadowsocksCiphers",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Bridges (Used for reaching the API)
        pub async fn get_bridges(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::BridgeList>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetBridges",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetBridges",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Split tunneling (Linux)
        pub async fn get_split_tunnel_processes(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<i32>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetSplitTunnelProcesses",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetSplitTunnelProcesses",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn add_split_tunnel_process(
            &mut self,
            request: impl tonic::IntoRequest<i32>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/AddSplitTunnelProcess",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "AddSplitTunnelProcess",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn remove_split_tunnel_process(
            &mut self,
            request: impl tonic::IntoRequest<i32>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/RemoveSplitTunnelProcess",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "RemoveSplitTunnelProcess",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn clear_split_tunnel_processes(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearSplitTunnelProcesses",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearSplitTunnelProcesses",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Split tunneling (Linux, Windows)
        pub async fn split_tunnel_is_supported(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SplitTunnelIsSupported",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SplitTunnelIsSupported",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Split tunneling (Windows, macOS, Android)
        pub async fn add_split_tunnel_app(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/AddSplitTunnelApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "AddSplitTunnelApp",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn remove_split_tunnel_app(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/RemoveSplitTunnelApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "RemoveSplitTunnelApp",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_split_tunnel_state(
            &mut self,
            request: impl tonic::IntoRequest<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetSplitTunnelState",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetSplitTunnelState",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Split tunneling (Windows, macOS)
        pub async fn clear_split_tunnel_apps(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearSplitTunnelApps",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearSplitTunnelApps",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_excluded_processes(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::ExcludedProcessList>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetExcludedProcesses",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetExcludedProcesses",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Play payment (Android)
        pub async fn init_play_purchase(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::PlayExternalObfuscatedAccountId>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/InitPlayPurchase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "InitPlayPurchase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn verify_play_purchase(
            &mut self,
            request: impl tonic::IntoRequest<super::PlayPurchase>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/VerifyPlayPurchase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "VerifyPlayPurchase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Check whether the app needs TCC approval for split tunneling (macOS)
        pub async fn need_full_disk_permissions(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/NeedFullDiskPermissions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "NeedFullDiskPermissions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Notify the split tunnel monitor that a volume was mounted or dismounted
        /// (Windows).
        pub async fn check_volumes(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/CheckVolumes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "CheckVolumes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Apply a JSON blob to the settings
        /// See ../../docs/settings-patch-format.md for a description of the format
        pub async fn apply_json_settings(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ApplyJsonSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ApplyJsonSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Return a JSON blob containing all overridable settings, if there are any
        pub async fn export_json_settings(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ExportJsonSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ExportJsonSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get current feature indicators
        pub async fn get_feature_indicators(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::FeatureIndicators>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetFeatureIndicators",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetFeatureIndicators",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Debug features
        pub async fn disable_relay(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/DisableRelay",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "DisableRelay",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn enable_relay(
            &mut self,
            request: impl tonic::IntoRequest<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/EnableRelay",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "EnableRelay",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_rollout_threshold(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::Rollout>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetRolloutThreshold",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetRolloutThreshold",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn regenerate_rollout_threshold(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::Rollout>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/RegenerateRolloutThreshold",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "RegenerateRolloutThreshold",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_rollout_threshold_seed(
            &mut self,
            request: impl tonic::IntoRequest<super::Seed>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetRolloutThresholdSeed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetRolloutThresholdSeed",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// App upgrade
        pub async fn app_upgrade(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/AppUpgrade",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "AppUpgrade",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn app_upgrade_abort(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/AppUpgradeAbort",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "AppUpgradeAbort",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn app_upgrade_events_listen(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::AppUpgradeEvent>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/AppUpgradeEventsListen",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "AppUpgradeEventsListen",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn get_app_upgrade_cache_dir(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetAppUpgradeCacheDir",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetAppUpgradeCacheDir",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn set_log_filter(
            &mut self,
            request: impl tonic::IntoRequest<super::LogFilter>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/SetLogFilter",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "SetLogFilter",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn log_listen(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::LogMessage>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/LogListen",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "LogListen",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// If the return value is SplitFilterMigration, a migration took place recently. After
        /// ClearMigrationMessage has been called, GetMigrationEvent will indefintely return null.
        /// If the return value is null, there is nothing for the clients to do. The migration has either
        /// not been run or was already completed.
        pub async fn get_migration_event(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::SplitFilterMigration>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/GetMigrationEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "GetMigrationEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Call this function after *handling* a SplitFilterMigration as returned by GetMigrationEvent to
        /// mark the migration as completed. This will cause GetMigrationEvent to return a null-value
        /// indefintely.
        pub async fn clear_migration_message(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/mullvad_daemon.management_interface.ManagementService/ClearMigrationMessage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "mullvad_daemon.management_interface.ManagementService",
                        "ClearMigrationMessage",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod management_service_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with ManagementServiceServer.
    #[async_trait]
    pub trait ManagementService: std::marker::Send + std::marker::Sync + 'static {
        /// Control and get tunnel state
        async fn connect_tunnel(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        async fn disconnect_tunnel(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        async fn reconnect_tunnel(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        async fn get_tunnel_state(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::TunnelState>, tonic::Status>;
        /// Server streaming response type for the EventsListen method.
        type EventsListenStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::DaemonEvent, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        /// Control the daemon and receive events
        async fn events_listen(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<Self::EventsListenStream>,
            tonic::Status,
        >;
        /// DEPRECATED: Prefer PrepareRestartV2.
        async fn prepare_restart(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Takes a a boolean argument which says whether the daemon should stop after
        /// it is done preparing for a restart.
        async fn prepare_restart_v2(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn factory_reset(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_current_version(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        >;
        /// Get information about the latest available version of the app.
        /// Note that calling this during an in-app upgrade will cancel the upgrade.
        async fn get_version_info(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::AppVersionInfo>, tonic::Status>;
        async fn is_performing_post_upgrade(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        /// Relays and tunnel constraints
        async fn update_relay_locations(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_relay_locations(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::RelayList>, tonic::Status>;
        async fn set_relay_settings(
            &self,
            request: tonic::Request<super::RelaySettings>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_obfuscation_settings(
            &self,
            request: tonic::Request<super::ObfuscationSettings>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Settings
        async fn get_settings(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::Settings>, tonic::Status>;
        async fn reset_settings(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_allow_lan(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_show_beta_releases(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_lockdown_mode(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_auto_connect(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_wireguard_mtu(
            &self,
            request: tonic::Request<u32>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_wireguard_allowed_ips(
            &self,
            request: tonic::Request<super::AllowedIpsList>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_enable_ipv6(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_quantum_resistant_tunnel(
            &self,
            request: tonic::Request<super::QuantumResistantState>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_enable_daita(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_daita_direct_only(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_daita_settings(
            &self,
            request: tonic::Request<super::DaitaSettings>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_dns_options(
            &self,
            request: tonic::Request<super::DnsOptions>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_relay_override(
            &self,
            request: tonic::Request<super::RelayOverride>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn clear_all_relay_overrides(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_enable_recents(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_userspace_wireguard(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Account management
        async fn create_new_account(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        >;
        async fn login_account(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn logout_account(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_account_data(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<super::AccountData>, tonic::Status>;
        async fn get_account_history(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::AccountHistory>, tonic::Status>;
        async fn clear_account_history(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_www_auth_token(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        >;
        async fn submit_voucher(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<
            tonic::Response<super::VoucherSubmission>,
            tonic::Status,
        >;
        /// Android only
        async fn delete_account(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Device management
        async fn get_device(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::DeviceState>, tonic::Status>;
        async fn update_device(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn list_devices(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<super::DeviceList>, tonic::Status>;
        async fn remove_device(
            &self,
            request: tonic::Request<super::DeviceRemoval>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// WireGuard key management
        async fn set_wireguard_rotation_interval(
            &self,
            request: tonic::Request<::prost_types::Duration>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn reset_wireguard_rotation_interval(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn rotate_wireguard_key(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_wireguard_key(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::PublicKey>, tonic::Status>;
        /// Custom lists
        async fn create_custom_list(
            &self,
            request: tonic::Request<super::NewCustomList>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        >;
        async fn delete_custom_list(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn update_custom_list(
            &self,
            request: tonic::Request<super::CustomList>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn clear_custom_lists(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Access methods
        async fn add_api_access_method(
            &self,
            request: tonic::Request<super::NewAccessMethodSetting>,
        ) -> std::result::Result<tonic::Response<super::Uuid>, tonic::Status>;
        async fn remove_api_access_method(
            &self,
            request: tonic::Request<super::Uuid>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_api_access_method(
            &self,
            request: tonic::Request<super::Uuid>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn update_api_access_method(
            &self,
            request: tonic::Request<super::AccessMethodSetting>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn clear_custom_api_access_methods(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_current_api_access_method(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<super::AccessMethodSetting>,
            tonic::Status,
        >;
        async fn test_custom_api_access_method(
            &self,
            request: tonic::Request<super::CustomProxy>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        async fn test_api_access_method_by_id(
            &self,
            request: tonic::Request<super::Uuid>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        /// Enumerate all supported Shadowsocks ciphers.
        async fn shadowsocks_ciphers(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<super::shadowsocks::Ciphers>,
            tonic::Status,
        >;
        /// Bridges (Used for reaching the API)
        async fn get_bridges(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::BridgeList>, tonic::Status>;
        /// Server streaming response type for the GetSplitTunnelProcesses method.
        type GetSplitTunnelProcessesStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<i32, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        /// Split tunneling (Linux)
        async fn get_split_tunnel_processes(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<Self::GetSplitTunnelProcessesStream>,
            tonic::Status,
        >;
        async fn add_split_tunnel_process(
            &self,
            request: tonic::Request<i32>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn remove_split_tunnel_process(
            &self,
            request: tonic::Request<i32>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn clear_split_tunnel_processes(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Split tunneling (Linux, Windows)
        async fn split_tunnel_is_supported(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        /// Split tunneling (Windows, macOS, Android)
        async fn add_split_tunnel_app(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn remove_split_tunnel_app(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn set_split_tunnel_state(
            &self,
            request: tonic::Request<bool>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Split tunneling (Windows, macOS)
        async fn clear_split_tunnel_apps(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_excluded_processes(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<super::ExcludedProcessList>,
            tonic::Status,
        >;
        /// Play payment (Android)
        async fn init_play_purchase(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<super::PlayExternalObfuscatedAccountId>,
            tonic::Status,
        >;
        async fn verify_play_purchase(
            &self,
            request: tonic::Request<super::PlayPurchase>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Check whether the app needs TCC approval for split tunneling (macOS)
        async fn need_full_disk_permissions(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<bool>, tonic::Status>;
        /// Notify the split tunnel monitor that a volume was mounted or dismounted
        /// (Windows).
        async fn check_volumes(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Apply a JSON blob to the settings
        /// See ../../docs/settings-patch-format.md for a description of the format
        async fn apply_json_settings(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Return a JSON blob containing all overridable settings, if there are any
        async fn export_json_settings(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        >;
        /// Get current feature indicators
        async fn get_feature_indicators(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<super::FeatureIndicators>,
            tonic::Status,
        >;
        /// Debug features
        async fn disable_relay(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn enable_relay(
            &self,
            request: tonic::Request<::prost::alloc::string::String>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn get_rollout_threshold(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::Rollout>, tonic::Status>;
        async fn regenerate_rollout_threshold(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<super::Rollout>, tonic::Status>;
        async fn set_rollout_threshold_seed(
            &self,
            request: tonic::Request<super::Seed>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// App upgrade
        async fn app_upgrade(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        async fn app_upgrade_abort(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Server streaming response type for the AppUpgradeEventsListen method.
        type AppUpgradeEventsListenStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::AppUpgradeEvent, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        async fn app_upgrade_events_listen(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<Self::AppUpgradeEventsListenStream>,
            tonic::Status,
        >;
        async fn get_app_upgrade_cache_dir(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<::prost::alloc::string::String>,
            tonic::Status,
        >;
        async fn set_log_filter(
            &self,
            request: tonic::Request<super::LogFilter>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Server streaming response type for the LogListen method.
        type LogListenStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::LogMessage, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        async fn log_listen(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<Self::LogListenStream>, tonic::Status>;
        /// If the return value is SplitFilterMigration, a migration took place recently. After
        /// ClearMigrationMessage has been called, GetMigrationEvent will indefintely return null.
        /// If the return value is null, there is nothing for the clients to do. The migration has either
        /// not been run or was already completed.
        async fn get_migration_event(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<
            tonic::Response<super::SplitFilterMigration>,
            tonic::Status,
        >;
        /// Call this function after *handling* a SplitFilterMigration as returned by GetMigrationEvent to
        /// mark the migration as completed. This will cause GetMigrationEvent to return a null-value
        /// indefintely.
        async fn clear_migration_message(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
    }
    #[derive(Debug)]
    pub struct ManagementServiceServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> ManagementServiceServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for ManagementServiceServer<T>
    where
        T: ManagementService,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/mullvad_daemon.management_interface.ManagementService/ConnectTunnel" => {
                    #[allow(non_camel_case_types)]
                    struct ConnectTunnelSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ConnectTunnelSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::connect_tunnel(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ConnectTunnelSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/DisconnectTunnel" => {
                    #[allow(non_camel_case_types)]
                    struct DisconnectTunnelSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for DisconnectTunnelSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::disconnect_tunnel(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DisconnectTunnelSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ReconnectTunnel" => {
                    #[allow(non_camel_case_types)]
                    struct ReconnectTunnelSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ReconnectTunnelSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::reconnect_tunnel(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ReconnectTunnelSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetTunnelState" => {
                    #[allow(non_camel_case_types)]
                    struct GetTunnelStateSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetTunnelStateSvc<T> {
                        type Response = super::TunnelState;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_tunnel_state(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetTunnelStateSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/EventsListen" => {
                    #[allow(non_camel_case_types)]
                    struct EventsListenSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::ServerStreamingService<()>
                    for EventsListenSvc<T> {
                        type Response = super::DaemonEvent;
                        type ResponseStream = T::EventsListenStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::events_listen(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = EventsListenSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/PrepareRestart" => {
                    #[allow(non_camel_case_types)]
                    struct PrepareRestartSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for PrepareRestartSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::prepare_restart(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = PrepareRestartSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/PrepareRestartV2" => {
                    #[allow(non_camel_case_types)]
                    struct PrepareRestartV2Svc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for PrepareRestartV2Svc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::prepare_restart_v2(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = PrepareRestartV2Svc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/FactoryReset" => {
                    #[allow(non_camel_case_types)]
                    struct FactoryResetSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for FactoryResetSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::factory_reset(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = FactoryResetSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetCurrentVersion" => {
                    #[allow(non_camel_case_types)]
                    struct GetCurrentVersionSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetCurrentVersionSvc<T> {
                        type Response = ::prost::alloc::string::String;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_current_version(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetCurrentVersionSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetVersionInfo" => {
                    #[allow(non_camel_case_types)]
                    struct GetVersionInfoSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetVersionInfoSvc<T> {
                        type Response = super::AppVersionInfo;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_version_info(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetVersionInfoSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/IsPerformingPostUpgrade" => {
                    #[allow(non_camel_case_types)]
                    struct IsPerformingPostUpgradeSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for IsPerformingPostUpgradeSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::is_performing_post_upgrade(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = IsPerformingPostUpgradeSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/UpdateRelayLocations" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateRelayLocationsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for UpdateRelayLocationsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::update_relay_locations(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UpdateRelayLocationsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetRelayLocations" => {
                    #[allow(non_camel_case_types)]
                    struct GetRelayLocationsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetRelayLocationsSvc<T> {
                        type Response = super::RelayList;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_relay_locations(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetRelayLocationsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetRelaySettings" => {
                    #[allow(non_camel_case_types)]
                    struct SetRelaySettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::RelaySettings>
                    for SetRelaySettingsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RelaySettings>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_relay_settings(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetRelaySettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetObfuscationSettings" => {
                    #[allow(non_camel_case_types)]
                    struct SetObfuscationSettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::ObfuscationSettings>
                    for SetObfuscationSettingsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ObfuscationSettings>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_obfuscation_settings(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetObfuscationSettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetSettings" => {
                    #[allow(non_camel_case_types)]
                    struct GetSettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetSettingsSvc<T> {
                        type Response = super::Settings;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_settings(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetSettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ResetSettings" => {
                    #[allow(non_camel_case_types)]
                    struct ResetSettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ResetSettingsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::reset_settings(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ResetSettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetAllowLan" => {
                    #[allow(non_camel_case_types)]
                    struct SetAllowLanSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetAllowLanSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_allow_lan(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetAllowLanSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetShowBetaReleases" => {
                    #[allow(non_camel_case_types)]
                    struct SetShowBetaReleasesSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetShowBetaReleasesSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_show_beta_releases(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetShowBetaReleasesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetLockdownMode" => {
                    #[allow(non_camel_case_types)]
                    struct SetLockdownModeSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetLockdownModeSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_lockdown_mode(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetLockdownModeSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetAutoConnect" => {
                    #[allow(non_camel_case_types)]
                    struct SetAutoConnectSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetAutoConnectSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_auto_connect(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetAutoConnectSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetWireguardMtu" => {
                    #[allow(non_camel_case_types)]
                    struct SetWireguardMtuSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<u32>
                    for SetWireguardMtuSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<u32>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_wireguard_mtu(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetWireguardMtuSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetWireguardAllowedIps" => {
                    #[allow(non_camel_case_types)]
                    struct SetWireguardAllowedIpsSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::AllowedIpsList>
                    for SetWireguardAllowedIpsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AllowedIpsList>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_wireguard_allowed_ips(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetWireguardAllowedIpsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetEnableIpv6" => {
                    #[allow(non_camel_case_types)]
                    struct SetEnableIpv6Svc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetEnableIpv6Svc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_enable_ipv6(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetEnableIpv6Svc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetQuantumResistantTunnel" => {
                    #[allow(non_camel_case_types)]
                    struct SetQuantumResistantTunnelSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::QuantumResistantState>
                    for SetQuantumResistantTunnelSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QuantumResistantState>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_quantum_resistant_tunnel(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetQuantumResistantTunnelSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetEnableDaita" => {
                    #[allow(non_camel_case_types)]
                    struct SetEnableDaitaSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetEnableDaitaSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_enable_daita(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetEnableDaitaSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetDaitaDirectOnly" => {
                    #[allow(non_camel_case_types)]
                    struct SetDaitaDirectOnlySvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetDaitaDirectOnlySvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_daita_direct_only(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetDaitaDirectOnlySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetDaitaSettings" => {
                    #[allow(non_camel_case_types)]
                    struct SetDaitaSettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::DaitaSettings>
                    for SetDaitaSettingsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DaitaSettings>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_daita_settings(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetDaitaSettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetDnsOptions" => {
                    #[allow(non_camel_case_types)]
                    struct SetDnsOptionsSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::DnsOptions>
                    for SetDnsOptionsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DnsOptions>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_dns_options(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetDnsOptionsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetRelayOverride" => {
                    #[allow(non_camel_case_types)]
                    struct SetRelayOverrideSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::RelayOverride>
                    for SetRelayOverrideSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RelayOverride>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_relay_override(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetRelayOverrideSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearAllRelayOverrides" => {
                    #[allow(non_camel_case_types)]
                    struct ClearAllRelayOverridesSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearAllRelayOverridesSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_all_relay_overrides(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearAllRelayOverridesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetEnableRecents" => {
                    #[allow(non_camel_case_types)]
                    struct SetEnableRecentsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetEnableRecentsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_enable_recents(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetEnableRecentsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetUserspaceWireguard" => {
                    #[allow(non_camel_case_types)]
                    struct SetUserspaceWireguardSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetUserspaceWireguardSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_userspace_wireguard(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetUserspaceWireguardSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/CreateNewAccount" => {
                    #[allow(non_camel_case_types)]
                    struct CreateNewAccountSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for CreateNewAccountSvc<T> {
                        type Response = ::prost::alloc::string::String;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::create_new_account(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CreateNewAccountSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/LoginAccount" => {
                    #[allow(non_camel_case_types)]
                    struct LoginAccountSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for LoginAccountSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::login_account(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = LoginAccountSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/LogoutAccount" => {
                    #[allow(non_camel_case_types)]
                    struct LogoutAccountSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for LogoutAccountSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::logout_account(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = LogoutAccountSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetAccountData" => {
                    #[allow(non_camel_case_types)]
                    struct GetAccountDataSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for GetAccountDataSvc<T> {
                        type Response = super::AccountData;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_account_data(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetAccountDataSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetAccountHistory" => {
                    #[allow(non_camel_case_types)]
                    struct GetAccountHistorySvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetAccountHistorySvc<T> {
                        type Response = super::AccountHistory;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_account_history(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetAccountHistorySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearAccountHistory" => {
                    #[allow(non_camel_case_types)]
                    struct ClearAccountHistorySvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearAccountHistorySvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_account_history(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearAccountHistorySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetWwwAuthToken" => {
                    #[allow(non_camel_case_types)]
                    struct GetWwwAuthTokenSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetWwwAuthTokenSvc<T> {
                        type Response = ::prost::alloc::string::String;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_www_auth_token(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetWwwAuthTokenSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SubmitVoucher" => {
                    #[allow(non_camel_case_types)]
                    struct SubmitVoucherSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for SubmitVoucherSvc<T> {
                        type Response = super::VoucherSubmission;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::submit_voucher(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SubmitVoucherSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/DeleteAccount" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteAccountSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for DeleteAccountSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::delete_account(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DeleteAccountSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetDevice" => {
                    #[allow(non_camel_case_types)]
                    struct GetDeviceSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetDeviceSvc<T> {
                        type Response = super::DeviceState;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_device(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetDeviceSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/UpdateDevice" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateDeviceSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for UpdateDeviceSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::update_device(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UpdateDeviceSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ListDevices" => {
                    #[allow(non_camel_case_types)]
                    struct ListDevicesSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for ListDevicesSvc<T> {
                        type Response = super::DeviceList;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::list_devices(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ListDevicesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/RemoveDevice" => {
                    #[allow(non_camel_case_types)]
                    struct RemoveDeviceSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::DeviceRemoval>
                    for RemoveDeviceSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeviceRemoval>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::remove_device(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RemoveDeviceSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetWireguardRotationInterval" => {
                    #[allow(non_camel_case_types)]
                    struct SetWireguardRotationIntervalSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost_types::Duration>
                    for SetWireguardRotationIntervalSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost_types::Duration>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_wireguard_rotation_interval(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetWireguardRotationIntervalSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ResetWireguardRotationInterval" => {
                    #[allow(non_camel_case_types)]
                    struct ResetWireguardRotationIntervalSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ResetWireguardRotationIntervalSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::reset_wireguard_rotation_interval(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ResetWireguardRotationIntervalSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/RotateWireguardKey" => {
                    #[allow(non_camel_case_types)]
                    struct RotateWireguardKeySvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for RotateWireguardKeySvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::rotate_wireguard_key(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RotateWireguardKeySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetWireguardKey" => {
                    #[allow(non_camel_case_types)]
                    struct GetWireguardKeySvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetWireguardKeySvc<T> {
                        type Response = super::PublicKey;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_wireguard_key(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetWireguardKeySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/CreateCustomList" => {
                    #[allow(non_camel_case_types)]
                    struct CreateCustomListSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::NewCustomList>
                    for CreateCustomListSvc<T> {
                        type Response = ::prost::alloc::string::String;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::NewCustomList>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::create_custom_list(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CreateCustomListSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/DeleteCustomList" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteCustomListSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for DeleteCustomListSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::delete_custom_list(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DeleteCustomListSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/UpdateCustomList" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateCustomListSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::CustomList>
                    for UpdateCustomListSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CustomList>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::update_custom_list(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UpdateCustomListSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearCustomLists" => {
                    #[allow(non_camel_case_types)]
                    struct ClearCustomListsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearCustomListsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_custom_lists(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearCustomListsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/AddApiAccessMethod" => {
                    #[allow(non_camel_case_types)]
                    struct AddApiAccessMethodSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::NewAccessMethodSetting>
                    for AddApiAccessMethodSvc<T> {
                        type Response = super::Uuid;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::NewAccessMethodSetting>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::add_api_access_method(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = AddApiAccessMethodSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/RemoveApiAccessMethod" => {
                    #[allow(non_camel_case_types)]
                    struct RemoveApiAccessMethodSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<super::Uuid>
                    for RemoveApiAccessMethodSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Uuid>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::remove_api_access_method(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RemoveApiAccessMethodSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetApiAccessMethod" => {
                    #[allow(non_camel_case_types)]
                    struct SetApiAccessMethodSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<super::Uuid>
                    for SetApiAccessMethodSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Uuid>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_api_access_method(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetApiAccessMethodSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/UpdateApiAccessMethod" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateApiAccessMethodSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::AccessMethodSetting>
                    for UpdateApiAccessMethodSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AccessMethodSetting>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::update_api_access_method(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UpdateApiAccessMethodSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearCustomApiAccessMethods" => {
                    #[allow(non_camel_case_types)]
                    struct ClearCustomApiAccessMethodsSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearCustomApiAccessMethodsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_custom_api_access_methods(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearCustomApiAccessMethodsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetCurrentApiAccessMethod" => {
                    #[allow(non_camel_case_types)]
                    struct GetCurrentApiAccessMethodSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetCurrentApiAccessMethodSvc<T> {
                        type Response = super::AccessMethodSetting;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_current_api_access_method(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetCurrentApiAccessMethodSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/TestCustomApiAccessMethod" => {
                    #[allow(non_camel_case_types)]
                    struct TestCustomApiAccessMethodSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::CustomProxy>
                    for TestCustomApiAccessMethodSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CustomProxy>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::test_custom_api_access_method(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = TestCustomApiAccessMethodSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/TestApiAccessMethodById" => {
                    #[allow(non_camel_case_types)]
                    struct TestApiAccessMethodByIdSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<super::Uuid>
                    for TestApiAccessMethodByIdSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Uuid>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::test_api_access_method_by_id(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = TestApiAccessMethodByIdSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ShadowsocksCiphers" => {
                    #[allow(non_camel_case_types)]
                    struct ShadowsocksCiphersSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ShadowsocksCiphersSvc<T> {
                        type Response = super::shadowsocks::Ciphers;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::shadowsocks_ciphers(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ShadowsocksCiphersSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetBridges" => {
                    #[allow(non_camel_case_types)]
                    struct GetBridgesSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetBridgesSvc<T> {
                        type Response = super::BridgeList;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_bridges(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetBridgesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetSplitTunnelProcesses" => {
                    #[allow(non_camel_case_types)]
                    struct GetSplitTunnelProcessesSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::ServerStreamingService<()>
                    for GetSplitTunnelProcessesSvc<T> {
                        type Response = i32;
                        type ResponseStream = T::GetSplitTunnelProcessesStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_split_tunnel_processes(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetSplitTunnelProcessesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/AddSplitTunnelProcess" => {
                    #[allow(non_camel_case_types)]
                    struct AddSplitTunnelProcessSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<i32>
                    for AddSplitTunnelProcessSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<i32>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::add_split_tunnel_process(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = AddSplitTunnelProcessSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/RemoveSplitTunnelProcess" => {
                    #[allow(non_camel_case_types)]
                    struct RemoveSplitTunnelProcessSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<i32>
                    for RemoveSplitTunnelProcessSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<i32>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::remove_split_tunnel_process(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RemoveSplitTunnelProcessSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearSplitTunnelProcesses" => {
                    #[allow(non_camel_case_types)]
                    struct ClearSplitTunnelProcessesSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearSplitTunnelProcessesSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_split_tunnel_processes(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearSplitTunnelProcessesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SplitTunnelIsSupported" => {
                    #[allow(non_camel_case_types)]
                    struct SplitTunnelIsSupportedSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for SplitTunnelIsSupportedSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::split_tunnel_is_supported(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SplitTunnelIsSupportedSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/AddSplitTunnelApp" => {
                    #[allow(non_camel_case_types)]
                    struct AddSplitTunnelAppSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for AddSplitTunnelAppSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::add_split_tunnel_app(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = AddSplitTunnelAppSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/RemoveSplitTunnelApp" => {
                    #[allow(non_camel_case_types)]
                    struct RemoveSplitTunnelAppSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for RemoveSplitTunnelAppSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::remove_split_tunnel_app(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RemoveSplitTunnelAppSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetSplitTunnelState" => {
                    #[allow(non_camel_case_types)]
                    struct SetSplitTunnelStateSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<bool>
                    for SetSplitTunnelStateSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<bool>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_split_tunnel_state(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetSplitTunnelStateSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearSplitTunnelApps" => {
                    #[allow(non_camel_case_types)]
                    struct ClearSplitTunnelAppsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearSplitTunnelAppsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_split_tunnel_apps(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearSplitTunnelAppsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetExcludedProcesses" => {
                    #[allow(non_camel_case_types)]
                    struct GetExcludedProcessesSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetExcludedProcessesSvc<T> {
                        type Response = super::ExcludedProcessList;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_excluded_processes(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetExcludedProcessesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/InitPlayPurchase" => {
                    #[allow(non_camel_case_types)]
                    struct InitPlayPurchaseSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for InitPlayPurchaseSvc<T> {
                        type Response = super::PlayExternalObfuscatedAccountId;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::init_play_purchase(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = InitPlayPurchaseSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/VerifyPlayPurchase" => {
                    #[allow(non_camel_case_types)]
                    struct VerifyPlayPurchaseSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::PlayPurchase>
                    for VerifyPlayPurchaseSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PlayPurchase>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::verify_play_purchase(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = VerifyPlayPurchaseSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/NeedFullDiskPermissions" => {
                    #[allow(non_camel_case_types)]
                    struct NeedFullDiskPermissionsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for NeedFullDiskPermissionsSvc<T> {
                        type Response = bool;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::need_full_disk_permissions(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = NeedFullDiskPermissionsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/CheckVolumes" => {
                    #[allow(non_camel_case_types)]
                    struct CheckVolumesSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for CheckVolumesSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::check_volumes(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CheckVolumesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ApplyJsonSettings" => {
                    #[allow(non_camel_case_types)]
                    struct ApplyJsonSettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for ApplyJsonSettingsSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::apply_json_settings(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ApplyJsonSettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ExportJsonSettings" => {
                    #[allow(non_camel_case_types)]
                    struct ExportJsonSettingsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ExportJsonSettingsSvc<T> {
                        type Response = ::prost::alloc::string::String;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::export_json_settings(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ExportJsonSettingsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetFeatureIndicators" => {
                    #[allow(non_camel_case_types)]
                    struct GetFeatureIndicatorsSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetFeatureIndicatorsSvc<T> {
                        type Response = super::FeatureIndicators;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_feature_indicators(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetFeatureIndicatorsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/DisableRelay" => {
                    #[allow(non_camel_case_types)]
                    struct DisableRelaySvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for DisableRelaySvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::disable_relay(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DisableRelaySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/EnableRelay" => {
                    #[allow(non_camel_case_types)]
                    struct EnableRelaySvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<::prost::alloc::string::String>
                    for EnableRelaySvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<::prost::alloc::string::String>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::enable_relay(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = EnableRelaySvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetRolloutThreshold" => {
                    #[allow(non_camel_case_types)]
                    struct GetRolloutThresholdSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetRolloutThresholdSvc<T> {
                        type Response = super::Rollout;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_rollout_threshold(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetRolloutThresholdSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/RegenerateRolloutThreshold" => {
                    #[allow(non_camel_case_types)]
                    struct RegenerateRolloutThresholdSvc<T: ManagementService>(
                        pub Arc<T>,
                    );
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for RegenerateRolloutThresholdSvc<T> {
                        type Response = super::Rollout;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::regenerate_rollout_threshold(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RegenerateRolloutThresholdSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetRolloutThresholdSeed" => {
                    #[allow(non_camel_case_types)]
                    struct SetRolloutThresholdSeedSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<super::Seed>
                    for SetRolloutThresholdSeedSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Seed>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_rollout_threshold_seed(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetRolloutThresholdSeedSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/AppUpgrade" => {
                    #[allow(non_camel_case_types)]
                    struct AppUpgradeSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for AppUpgradeSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::app_upgrade(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = AppUpgradeSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/AppUpgradeAbort" => {
                    #[allow(non_camel_case_types)]
                    struct AppUpgradeAbortSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for AppUpgradeAbortSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::app_upgrade_abort(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = AppUpgradeAbortSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/AppUpgradeEventsListen" => {
                    #[allow(non_camel_case_types)]
                    struct AppUpgradeEventsListenSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::ServerStreamingService<()>
                    for AppUpgradeEventsListenSvc<T> {
                        type Response = super::AppUpgradeEvent;
                        type ResponseStream = T::AppUpgradeEventsListenStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::app_upgrade_events_listen(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = AppUpgradeEventsListenSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetAppUpgradeCacheDir" => {
                    #[allow(non_camel_case_types)]
                    struct GetAppUpgradeCacheDirSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetAppUpgradeCacheDirSvc<T> {
                        type Response = ::prost::alloc::string::String;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_app_upgrade_cache_dir(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetAppUpgradeCacheDirSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/SetLogFilter" => {
                    #[allow(non_camel_case_types)]
                    struct SetLogFilterSvc<T: ManagementService>(pub Arc<T>);
                    impl<
                        T: ManagementService,
                    > tonic::server::UnaryService<super::LogFilter>
                    for SetLogFilterSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::LogFilter>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::set_log_filter(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SetLogFilterSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/LogListen" => {
                    #[allow(non_camel_case_types)]
                    struct LogListenSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::ServerStreamingService<()>
                    for LogListenSvc<T> {
                        type Response = super::LogMessage;
                        type ResponseStream = T::LogListenStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::log_listen(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = LogListenSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/GetMigrationEvent" => {
                    #[allow(non_camel_case_types)]
                    struct GetMigrationEventSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for GetMigrationEventSvc<T> {
                        type Response = super::SplitFilterMigration;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::get_migration_event(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetMigrationEventSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/mullvad_daemon.management_interface.ManagementService/ClearMigrationMessage" => {
                    #[allow(non_camel_case_types)]
                    struct ClearMigrationMessageSvc<T: ManagementService>(pub Arc<T>);
                    impl<T: ManagementService> tonic::server::UnaryService<()>
                    for ClearMigrationMessageSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ManagementService>::clear_migration_message(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ClearMigrationMessageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for ManagementServiceServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "mullvad_daemon.management_interface.ManagementService";
    impl<T> tonic::server::NamedService for ManagementServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
