import Foundation
import GRPC
import NIOTransportServices
import SwiftProtobuf

public typealias TunnelClient = Burrow_TunnelAsyncClient
public typealias NetworksClient = Burrow_NetworksAsyncClient

public protocol Client {
    init(channel: GRPCChannel)
}

extension Client {
    public static func unix(socketURL: URL) -> Self {
        let group = NIOTSEventLoopGroup()
        let configuration = ClientConnection.Configuration.default(
            target: .unixDomainSocket(socketURL.path),
            eventLoopGroup: group
        )
        return Self(channel: ClientConnection(configuration: configuration))
    }
}

extension TunnelClient: Client {
    public init(channel: any GRPCChannel) {
        self.init(channel: channel, defaultCallOptions: .init(), interceptors: .none)
    }
}

extension NetworksClient: Client {
    public init(channel: any GRPCChannel) {
        self.init(channel: channel, defaultCallOptions: .init(), interceptors: .none)
    }
}

public struct Burrow_TailnetDiscoverRequest: Sendable {
    public var email: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetDiscoverResponse: Sendable {
    public var domain: String = ""
    public var authority: String = ""
    public var oidcIssuer: String = ""
    public var managed: Bool = false
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetProbeRequest: Sendable {
    public var authority: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetProbeResponse: Sendable {
    public var authority: String = ""
    public var statusCode: Int32 = 0
    public var summary: String = ""
    public var detail: String = ""
    public var reachable: Bool = false
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetLoginStartRequest: Sendable {
    public var accountName: String = ""
    public var identityName: String = ""
    public var hostname: String = ""
    public var authority: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetLoginStatusRequest: Sendable {
    public var sessionID: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetLoginCancelRequest: Sendable {
    public var sessionID: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TailnetLoginStatusResponse: Sendable {
    public var sessionID: String = ""
    public var backendState: String = ""
    public var authURL: String = ""
    public var running: Bool = false
    public var needsLogin: Bool = false
    public var tailnetName: String = ""
    public var magicDNSSuffix: String = ""
    public var selfDNSName: String = ""
    public var tailnetIPs: [String] = []
    public var health: [String] = []
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionImportRequest: Sendable {
    public var url: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionNodePreview: Sendable {
    public var ordinal: Int32 = 0
    public var name: String = ""
    public var `protocol`: String = ""
    public var server: String = ""
    public var port: Int32 = 0
    public var warnings: [String] = []
    public var runtimeSupported: Bool = false
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionRejectedEntry: Sendable {
    public var ordinal: Int32 = 0
    public var reason: String = ""
    public var scheme: String = ""
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionPreviewResponse: Sendable {
    public var suggestedName: String = ""
    public var detectedFormat: String = ""
    public var compatibleCount: Int32 = 0
    public var rejectedCount: Int32 = 0
    public var node: [Burrow_ProxySubscriptionNodePreview] = []
    public var rejected: [Burrow_ProxySubscriptionRejectedEntry] = []
    public var warnings: [String] = []
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionApplyRequest: Sendable {
    public var id: Int32 = 0
    public var url: String = ""
    public var name: String = ""
    public var selectedOrdinal: Int32 = 0
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionApplyResponse: Sendable {
    public var id: Int32 = 0
    public var importedCount: Int32 = 0
    public var selectedOrdinal: Int32 = 0
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionSelectRequest: Sendable {
    public var id: Int32 = 0
    public var selectedOrdinal: Int32 = 0
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_ProxySubscriptionSelectResponse: Sendable {
    public var id: Int32 = 0
    public var selectedOrdinal: Int32 = 0
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

public struct Burrow_TunnelPacket: Sendable {
    public var payload = Data()
    public var unknownFields = SwiftProtobuf.UnknownStorage()

    public init() {}
}

extension Burrow_TailnetDiscoverRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetDiscoverRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "email")
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.email)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.email.isEmpty {
            try visitor.visitSingularStringField(value: self.email, fieldNumber: 1)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetDiscoverResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetDiscoverResponse"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "domain"),
        2: .same(proto: "authority"),
        3: .same(proto: "oidc_issuer"),
        4: .same(proto: "managed"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.domain)
            case 2: try decoder.decodeSingularStringField(value: &self.authority)
            case 3: try decoder.decodeSingularStringField(value: &self.oidcIssuer)
            case 4: try decoder.decodeSingularBoolField(value: &self.managed)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.domain.isEmpty {
            try visitor.visitSingularStringField(value: self.domain, fieldNumber: 1)
        }
        if !self.authority.isEmpty {
            try visitor.visitSingularStringField(value: self.authority, fieldNumber: 2)
        }
        if !self.oidcIssuer.isEmpty {
            try visitor.visitSingularStringField(value: self.oidcIssuer, fieldNumber: 3)
        }
        if self.managed {
            try visitor.visitSingularBoolField(value: self.managed, fieldNumber: 4)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetProbeRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetProbeRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "authority")
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.authority)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.authority.isEmpty {
            try visitor.visitSingularStringField(value: self.authority, fieldNumber: 1)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetProbeResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetProbeResponse"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "authority"),
        2: .same(proto: "status_code"),
        3: .same(proto: "summary"),
        4: .same(proto: "detail"),
        5: .same(proto: "reachable"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.authority)
            case 2: try decoder.decodeSingularInt32Field(value: &self.statusCode)
            case 3: try decoder.decodeSingularStringField(value: &self.summary)
            case 4: try decoder.decodeSingularStringField(value: &self.detail)
            case 5: try decoder.decodeSingularBoolField(value: &self.reachable)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.authority.isEmpty {
            try visitor.visitSingularStringField(value: self.authority, fieldNumber: 1)
        }
        if self.statusCode != 0 {
            try visitor.visitSingularInt32Field(value: self.statusCode, fieldNumber: 2)
        }
        if !self.summary.isEmpty {
            try visitor.visitSingularStringField(value: self.summary, fieldNumber: 3)
        }
        if !self.detail.isEmpty {
            try visitor.visitSingularStringField(value: self.detail, fieldNumber: 4)
        }
        if self.reachable {
            try visitor.visitSingularBoolField(value: self.reachable, fieldNumber: 5)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetLoginStartRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetLoginStartRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .standard(proto: "account_name"),
        2: .standard(proto: "identity_name"),
        3: .same(proto: "hostname"),
        4: .same(proto: "authority"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.accountName)
            case 2: try decoder.decodeSingularStringField(value: &self.identityName)
            case 3: try decoder.decodeSingularStringField(value: &self.hostname)
            case 4: try decoder.decodeSingularStringField(value: &self.authority)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.accountName.isEmpty {
            try visitor.visitSingularStringField(value: self.accountName, fieldNumber: 1)
        }
        if !self.identityName.isEmpty {
            try visitor.visitSingularStringField(value: self.identityName, fieldNumber: 2)
        }
        if !self.hostname.isEmpty {
            try visitor.visitSingularStringField(value: self.hostname, fieldNumber: 3)
        }
        if !self.authority.isEmpty {
            try visitor.visitSingularStringField(value: self.authority, fieldNumber: 4)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetLoginStatusRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetLoginStatusRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .standard(proto: "session_id")
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.sessionID)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.sessionID.isEmpty {
            try visitor.visitSingularStringField(value: self.sessionID, fieldNumber: 1)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetLoginCancelRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetLoginCancelRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .standard(proto: "session_id")
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.sessionID)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.sessionID.isEmpty {
            try visitor.visitSingularStringField(value: self.sessionID, fieldNumber: 1)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TailnetLoginStatusResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TailnetLoginStatusResponse"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .standard(proto: "session_id"),
        2: .standard(proto: "backend_state"),
        3: .standard(proto: "auth_url"),
        4: .same(proto: "running"),
        5: .standard(proto: "needs_login"),
        6: .standard(proto: "tailnet_name"),
        7: .standard(proto: "magic_dns_suffix"),
        8: .standard(proto: "self_dns_name"),
        9: .standard(proto: "tailnet_ips"),
        10: .same(proto: "health"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.sessionID)
            case 2: try decoder.decodeSingularStringField(value: &self.backendState)
            case 3: try decoder.decodeSingularStringField(value: &self.authURL)
            case 4: try decoder.decodeSingularBoolField(value: &self.running)
            case 5: try decoder.decodeSingularBoolField(value: &self.needsLogin)
            case 6: try decoder.decodeSingularStringField(value: &self.tailnetName)
            case 7: try decoder.decodeSingularStringField(value: &self.magicDNSSuffix)
            case 8: try decoder.decodeSingularStringField(value: &self.selfDNSName)
            case 9: try decoder.decodeRepeatedStringField(value: &self.tailnetIPs)
            case 10: try decoder.decodeRepeatedStringField(value: &self.health)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.sessionID.isEmpty {
            try visitor.visitSingularStringField(value: self.sessionID, fieldNumber: 1)
        }
        if !self.backendState.isEmpty {
            try visitor.visitSingularStringField(value: self.backendState, fieldNumber: 2)
        }
        if !self.authURL.isEmpty {
            try visitor.visitSingularStringField(value: self.authURL, fieldNumber: 3)
        }
        if self.running {
            try visitor.visitSingularBoolField(value: self.running, fieldNumber: 4)
        }
        if self.needsLogin {
            try visitor.visitSingularBoolField(value: self.needsLogin, fieldNumber: 5)
        }
        if !self.tailnetName.isEmpty {
            try visitor.visitSingularStringField(value: self.tailnetName, fieldNumber: 6)
        }
        if !self.magicDNSSuffix.isEmpty {
            try visitor.visitSingularStringField(value: self.magicDNSSuffix, fieldNumber: 7)
        }
        if !self.selfDNSName.isEmpty {
            try visitor.visitSingularStringField(value: self.selfDNSName, fieldNumber: 8)
        }
        if !self.tailnetIPs.isEmpty {
            try visitor.visitRepeatedStringField(value: self.tailnetIPs, fieldNumber: 9)
        }
        if !self.health.isEmpty {
            try visitor.visitRepeatedStringField(value: self.health, fieldNumber: 10)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_TunnelPacket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.TunnelPacket"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "payload")
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularBytesField(value: &self.payload)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.payload.isEmpty {
            try visitor.visitSingularBytesField(value: self.payload, fieldNumber: 1)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionImportRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionImportRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "url")
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.url)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.url.isEmpty {
            try visitor.visitSingularStringField(value: self.url, fieldNumber: 1)
        }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionNodePreview: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionNodePreview"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "ordinal"),
        2: .same(proto: "name"),
        3: .same(proto: "protocol"),
        4: .same(proto: "server"),
        5: .same(proto: "port"),
        6: .same(proto: "warnings"),
        7: .standard(proto: "runtime_supported"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularInt32Field(value: &self.ordinal)
            case 2: try decoder.decodeSingularStringField(value: &self.name)
            case 3: try decoder.decodeSingularStringField(value: &self.`protocol`)
            case 4: try decoder.decodeSingularStringField(value: &self.server)
            case 5: try decoder.decodeSingularInt32Field(value: &self.port)
            case 6: try decoder.decodeRepeatedStringField(value: &self.warnings)
            case 7: try decoder.decodeSingularBoolField(value: &self.runtimeSupported)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if self.ordinal != 0 { try visitor.visitSingularInt32Field(value: self.ordinal, fieldNumber: 1) }
        if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 2) }
        if !self.`protocol`.isEmpty { try visitor.visitSingularStringField(value: self.`protocol`, fieldNumber: 3) }
        if !self.server.isEmpty { try visitor.visitSingularStringField(value: self.server, fieldNumber: 4) }
        if self.port != 0 { try visitor.visitSingularInt32Field(value: self.port, fieldNumber: 5) }
        if !self.warnings.isEmpty { try visitor.visitRepeatedStringField(value: self.warnings, fieldNumber: 6) }
        if self.runtimeSupported { try visitor.visitSingularBoolField(value: self.runtimeSupported, fieldNumber: 7) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionRejectedEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionRejectedEntry"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "ordinal"),
        2: .same(proto: "reason"),
        3: .same(proto: "scheme"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularInt32Field(value: &self.ordinal)
            case 2: try decoder.decodeSingularStringField(value: &self.reason)
            case 3: try decoder.decodeSingularStringField(value: &self.scheme)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if self.ordinal != 0 { try visitor.visitSingularInt32Field(value: self.ordinal, fieldNumber: 1) }
        if !self.reason.isEmpty { try visitor.visitSingularStringField(value: self.reason, fieldNumber: 2) }
        if !self.scheme.isEmpty { try visitor.visitSingularStringField(value: self.scheme, fieldNumber: 3) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionPreviewResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionPreviewResponse"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .standard(proto: "suggested_name"),
        2: .standard(proto: "detected_format"),
        3: .standard(proto: "compatible_count"),
        4: .standard(proto: "rejected_count"),
        5: .same(proto: "node"),
        6: .same(proto: "rejected"),
        7: .same(proto: "warnings"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularStringField(value: &self.suggestedName)
            case 2: try decoder.decodeSingularStringField(value: &self.detectedFormat)
            case 3: try decoder.decodeSingularInt32Field(value: &self.compatibleCount)
            case 4: try decoder.decodeSingularInt32Field(value: &self.rejectedCount)
            case 5: try decoder.decodeRepeatedMessageField(value: &self.node)
            case 6: try decoder.decodeRepeatedMessageField(value: &self.rejected)
            case 7: try decoder.decodeRepeatedStringField(value: &self.warnings)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if !self.suggestedName.isEmpty { try visitor.visitSingularStringField(value: self.suggestedName, fieldNumber: 1) }
        if !self.detectedFormat.isEmpty { try visitor.visitSingularStringField(value: self.detectedFormat, fieldNumber: 2) }
        if self.compatibleCount != 0 { try visitor.visitSingularInt32Field(value: self.compatibleCount, fieldNumber: 3) }
        if self.rejectedCount != 0 { try visitor.visitSingularInt32Field(value: self.rejectedCount, fieldNumber: 4) }
        if !self.node.isEmpty { try visitor.visitRepeatedMessageField(value: self.node, fieldNumber: 5) }
        if !self.rejected.isEmpty { try visitor.visitRepeatedMessageField(value: self.rejected, fieldNumber: 6) }
        if !self.warnings.isEmpty { try visitor.visitRepeatedStringField(value: self.warnings, fieldNumber: 7) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionApplyRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionApplyRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "id"),
        2: .same(proto: "url"),
        3: .same(proto: "name"),
        4: .standard(proto: "selected_ordinal"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularInt32Field(value: &self.id)
            case 2: try decoder.decodeSingularStringField(value: &self.url)
            case 3: try decoder.decodeSingularStringField(value: &self.name)
            case 4: try decoder.decodeSingularInt32Field(value: &self.selectedOrdinal)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if self.id != 0 { try visitor.visitSingularInt32Field(value: self.id, fieldNumber: 1) }
        if !self.url.isEmpty { try visitor.visitSingularStringField(value: self.url, fieldNumber: 2) }
        if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 3) }
        if self.selectedOrdinal != 0 { try visitor.visitSingularInt32Field(value: self.selectedOrdinal, fieldNumber: 4) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionApplyResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionApplyResponse"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "id"),
        2: .standard(proto: "imported_count"),
        3: .standard(proto: "selected_ordinal"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularInt32Field(value: &self.id)
            case 2: try decoder.decodeSingularInt32Field(value: &self.importedCount)
            case 3: try decoder.decodeSingularInt32Field(value: &self.selectedOrdinal)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if self.id != 0 { try visitor.visitSingularInt32Field(value: self.id, fieldNumber: 1) }
        if self.importedCount != 0 { try visitor.visitSingularInt32Field(value: self.importedCount, fieldNumber: 2) }
        if self.selectedOrdinal != 0 { try visitor.visitSingularInt32Field(value: self.selectedOrdinal, fieldNumber: 3) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionSelectRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionSelectRequest"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "id"),
        2: .standard(proto: "selected_ordinal"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularInt32Field(value: &self.id)
            case 2: try decoder.decodeSingularInt32Field(value: &self.selectedOrdinal)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if self.id != 0 { try visitor.visitSingularInt32Field(value: self.id, fieldNumber: 1) }
        if self.selectedOrdinal != 0 { try visitor.visitSingularInt32Field(value: self.selectedOrdinal, fieldNumber: 2) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

extension Burrow_ProxySubscriptionSelectResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
    public static let protoMessageName: String = "burrow.ProxySubscriptionSelectResponse"
    public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
        1: .same(proto: "id"),
        2: .standard(proto: "selected_ordinal"),
    ]

    public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
        while let fieldNumber = try decoder.nextFieldNumber() {
            switch fieldNumber {
            case 1: try decoder.decodeSingularInt32Field(value: &self.id)
            case 2: try decoder.decodeSingularInt32Field(value: &self.selectedOrdinal)
            default: break
            }
        }
    }

    public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
        if self.id != 0 { try visitor.visitSingularInt32Field(value: self.id, fieldNumber: 1) }
        if self.selectedOrdinal != 0 { try visitor.visitSingularInt32Field(value: self.selectedOrdinal, fieldNumber: 2) }
        try unknownFields.traverse(visitor: &visitor)
    }
}

public struct TailnetClient: Client, GRPCClient {
    public let channel: GRPCChannel
    public var defaultCallOptions: CallOptions

    public init(channel: any GRPCChannel) {
        self.channel = channel
        self.defaultCallOptions = .init()
    }

    public func discover(
        _ request: Burrow_TailnetDiscoverRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_TailnetDiscoverResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.TailnetControl/Discover",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }

    public func probe(
        _ request: Burrow_TailnetProbeRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_TailnetProbeResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.TailnetControl/Probe",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }

    public func loginStart(
        _ request: Burrow_TailnetLoginStartRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_TailnetLoginStatusResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.TailnetControl/LoginStart",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }

    public func loginStatus(
        _ request: Burrow_TailnetLoginStatusRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_TailnetLoginStatusResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.TailnetControl/LoginStatus",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }

    public func loginCancel(
        _ request: Burrow_TailnetLoginCancelRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_Empty {
        try await self.performAsyncUnaryCall(
            path: "/burrow.TailnetControl/LoginCancel",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }
}

public struct ProxySubscriptionClient: Client, GRPCClient {
    public let channel: GRPCChannel
    public var defaultCallOptions: CallOptions

    public init(channel: any GRPCChannel) {
        self.channel = channel
        self.defaultCallOptions = .init()
    }

    public func previewImport(
        _ request: Burrow_ProxySubscriptionImportRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_ProxySubscriptionPreviewResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.ProxySubscriptions/PreviewImport",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }

    public func applyImport(
        _ request: Burrow_ProxySubscriptionApplyRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_ProxySubscriptionApplyResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.ProxySubscriptions/ApplyImport",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }

    public func selectNode(
        _ request: Burrow_ProxySubscriptionSelectRequest,
        callOptions: CallOptions? = nil
    ) async throws -> Burrow_ProxySubscriptionSelectResponse {
        try await self.performAsyncUnaryCall(
            path: "/burrow.ProxySubscriptions/SelectNode",
            request: request,
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }
}

public struct TunnelPacketClient: Client, GRPCClient {
    public let channel: GRPCChannel
    public var defaultCallOptions: CallOptions

    public init(channel: any GRPCChannel) {
        self.channel = channel
        self.defaultCallOptions = .init()
    }

    public func makeTunnelPacketsCall(
        callOptions: CallOptions? = nil
    ) -> GRPCAsyncBidirectionalStreamingCall<Burrow_TunnelPacket, Burrow_TunnelPacket> {
        self.makeAsyncBidirectionalStreamingCall(
            path: "/burrow.Tunnel/TunnelPackets",
            callOptions: callOptions ?? self.defaultCallOptions,
            interceptors: []
        )
    }
}