// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 6.0.3 effective-5.10 (swiftlang-6.0.3.1.10 clang-1600.0.30.1)
// swift-module-flags: -target arm64-apple-ios12.0-simulator -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -O -enable-bare-slash-regex -module-name Connect
// swift-module-flags-ignorable: -no-verify-emitted-module-interface
@_exported import Connect
import Foundation
import Swift
import SwiftProtobuf
import _Concurrency
import _StringProcessing
import _SwiftConcurrencyShims
import os.log
import os
import zlib
#if compiler(>=5.3) && $PrimaryAssociatedTypes2
@available(iOS 13, *)
public protocol BidirectionalAsyncStreamInterface<Input, Output> : Swift.Sendable {
  associatedtype Input : SwiftProtobuf.Message
  associatedtype Output : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) throws -> Self
  func results() -> _Concurrency.AsyncStream<Connect.StreamResult<Self.Output>>
  func close()
  func cancel()
}
#else
@available(iOS 13, *)
public protocol BidirectionalAsyncStreamInterface : Swift.Sendable {
  associatedtype Input : SwiftProtobuf.Message
  associatedtype Output : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) throws -> Self
  func results() -> _Concurrency.AsyncStream<Connect.StreamResult<Self.Output>>
  func close()
  func cancel()
}
#endif
#if compiler(>=5.3) && $PrimaryAssociatedTypes2
public protocol BidirectionalStreamInterface<Input> {
  associatedtype Input : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) -> Self
  func close()
  func cancel()
}
#else
public protocol BidirectionalStreamInterface {
  associatedtype Input : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) -> Self
  func close()
  func cancel()
}
#endif
public struct Cancelable : Swift.Sendable {
  public let cancel: @Sendable () -> Swift.Void
  public init(cancel: @escaping @Sendable () -> Swift.Void)
}
#if compiler(>=5.3) && $PrimaryAssociatedTypes2
@available(iOS 13, *)
public protocol ClientOnlyAsyncStreamInterface<Input, Output> : Swift.Sendable {
  associatedtype Input : SwiftProtobuf.Message
  associatedtype Output : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) throws -> Self
  func results() -> _Concurrency.AsyncStream<Connect.StreamResult<Self.Output>>
  func closeAndReceive()
  func cancel()
}
#else
@available(iOS 13, *)
public protocol ClientOnlyAsyncStreamInterface : Swift.Sendable {
  associatedtype Input : SwiftProtobuf.Message
  associatedtype Output : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) throws -> Self
  func results() -> _Concurrency.AsyncStream<Connect.StreamResult<Self.Output>>
  func closeAndReceive()
  func cancel()
}
#endif
#if compiler(>=5.3) && $PrimaryAssociatedTypes2
public protocol ClientOnlyStreamInterface<Input> {
  associatedtype Input : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) throws -> Self
  func closeAndReceive()
  func cancel()
}
#else
public protocol ClientOnlyStreamInterface {
  associatedtype Input : SwiftProtobuf.Message
  @discardableResult
  func send(_ input: Self.Input) throws -> Self
  func closeAndReceive()
  func cancel()
}
#endif
public enum Code : Swift.Int, Swift.CaseIterable, Swift.Equatable, Swift.Sendable {
  case ok
  case canceled
  case unknown
  case invalidArgument
  case deadlineExceeded
  case notFound
  case alreadyExists
  case permissionDenied
  case resourceExhausted
  case failedPrecondition
  case aborted
  case outOfRange
  case unimplemented
  case internalError
  case unavailable
  case dataLoss
  case unauthenticated
  public var name: Swift.String {
    get
  }
  public static func fromHTTPStatus(_ status: Swift.Int) -> Connect.Code
  public static func fromName(_ name: Swift.String) -> Connect.Code?
  public init?(rawValue: Swift.Int)
  public typealias AllCases = [Connect.Code]
  public typealias RawValue = Swift.Int
  nonisolated public static var allCases: [Connect.Code] {
    get
  }
  public var rawValue: Swift.Int {
    get
  }
}
public protocol Codec : Swift.Sendable {
  func name() -> Swift.String
  func serialize<Input>(message: Input) throws -> Foundation.Data where Input : SwiftProtobuf.Message
  func deterministicallySerialize<Input>(message: Input) throws -> Foundation.Data where Input : SwiftProtobuf.Message
  func deserialize<Output>(source: Foundation.Data) throws -> Output where Output : SwiftProtobuf.Message
}
public protocol CompressionPool : Swift.Sendable {
  func name() -> Swift.String
  func compress(data: Foundation.Data) throws -> Foundation.Data
  func decompress(data: Foundation.Data) throws -> Foundation.Data
}
public struct ConnectError : Swift.Error, Swift.Sendable {
  public let code: Connect.Code
  public let message: Swift.String?
  public let exception: (any Swift.Error)?
  public let details: [Connect.ConnectError.Detail]
  public let metadata: Connect.Headers
  public func unpackedDetails<Output>() -> [Output] where Output : SwiftProtobuf.Message
  public init(code: Connect.Code, message: Swift.String?, exception: (any Swift.Error)? = nil, details: [Connect.ConnectError.Detail] = [], metadata: Connect.Headers = [:])
  public struct Detail : Swift.Decodable, Swift.Sendable {
    public let type: Swift.String
    public let payload: Foundation.Data?
    public init(from decoder: any Swift.Decoder) throws
    public init(type: Swift.String, payload: Foundation.Data?)
  }
}
extension Connect.ConnectError : Swift.Decodable {
  public init(from decoder: any Swift.Decoder) throws
}
extension Connect.ConnectError {
  public static func from(code: Connect.Code, headers: Connect.Headers?, trailers: Connect.Trailers?, source: Foundation.Data?) -> Connect.ConnectError
  public static func canceled() -> Connect.ConnectError
}
extension Connect.ConnectError {
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public static func _parseGRPCHeaders(_ headers: Connect.Headers?, trailers: Connect.Trailers?) -> (grpcCode: Connect.Code, error: Connect.ConnectError?)
}
@available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
public enum Envelope {
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public static var _prefixLength: Swift.Int {
    get
  }
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public static func _packMessage(_ source: Foundation.Data, using compression: Connect.ProtocolClientConfig.RequestCompression?) -> Foundation.Data
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public static func _unpackMessage(_ source: Foundation.Data, compressionPool: (any Connect.CompressionPool)?) throws -> (headerByte: Swift.UInt8, unpacked: Foundation.Data)
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public static func _isCompressed(_ packedData: Foundation.Data) -> Swift.Bool
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public static func _messageLength(forPackedData data: Foundation.Data) -> Swift.Int
}
public struct GzipCompressionPool : Swift.Sendable {
  public init()
  public enum GzipError : Swift.Error {
    case failedToInitialize
    case failedToFinish
    public static func == (a: Connect.GzipCompressionPool.GzipError, b: Connect.GzipCompressionPool.GzipError) -> Swift.Bool
    public func hash(into hasher: inout Swift.Hasher)
    public var hashValue: Swift.Int {
      get
    }
  }
}
extension Connect.GzipCompressionPool : Connect.CompressionPool {
  public func name() -> Swift.String
  public func compress(data: Foundation.Data) throws -> Foundation.Data
  public func decompress(data: Foundation.Data) throws -> Foundation.Data
}
public enum HeaderConstants {
  public static let acceptEncoding: Swift.String
  public static let contentEncoding: Swift.String
  public static let contentType: Swift.String
  public static let connectProtocolVersion: Swift.String
  public static let connectTimeoutMs: Swift.String
  public static let connectStreamingAcceptEncoding: Swift.String
  public static let connectStreamingContentEncoding: Swift.String
  public static let xUserAgent: Swift.String
  public static let grpcAcceptEncoding: Swift.String
  public static let grpcContentEncoding: Swift.String
  public static let grpcMessage: Swift.String
  public static let grpcStatus: Swift.String
  public static let grpcStatusDetails: Swift.String
  public static let grpcTimeout: Swift.String
  public static let grpcTE: Swift.String
}
public typealias Headers = [Swift.String : [Swift.String]]
extension Swift.Dictionary where Key == Swift.String, Value == [Swift.String] {
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public func _addingGRPCHeaders(using config: Connect.ProtocolClientConfig, grpcWeb: Swift.Bool) -> Swift.Dictionary<Key, Value>
}
public protocol HTTPClientInterface : Swift.Sendable {
  @discardableResult
  func unary(request: Connect.HTTPRequest<Foundation.Data?>, onMetrics: @escaping @Sendable (Connect.HTTPMetrics) -> Swift.Void, onResponse: @escaping @Sendable (Connect.HTTPResponse) -> Swift.Void) -> Connect.Cancelable
  func stream(request: Connect.HTTPRequest<Foundation.Data?>, responseCallbacks: Connect.ResponseCallbacks) -> Connect.RequestCallbacks<Foundation.Data>
}
public enum HTTPMethod : Swift.String, Swift.Sendable {
  case get
  case post
  public init?(rawValue: Swift.String)
  public typealias RawValue = Swift.String
  public var rawValue: Swift.String {
    get
  }
}
public struct HTTPMetrics : Swift.Sendable {
  public let taskMetrics: Foundation.URLSessionTaskMetrics?
  public init(taskMetrics: Foundation.URLSessionTaskMetrics?)
}
public struct HTTPRequest<Input> : Swift.Sendable where Input : Swift.Sendable {
  public let url: Foundation.URL
  public let headers: Connect.Headers
  public let message: Input
  public let method: Connect.HTTPMethod
  public let trailers: Connect.Trailers?
  public let idempotencyLevel: Connect.IdempotencyLevel
  public init(url: Foundation.URL, headers: Connect.Headers, message: Input, method: Connect.HTTPMethod, trailers: Connect.Trailers?, idempotencyLevel: Connect.IdempotencyLevel)
}
public struct HTTPResponse : Swift.Sendable {
  public let code: Connect.Code
  public let headers: Connect.Headers
  public let message: Foundation.Data?
  public let trailers: Connect.Trailers
  public let error: (any Swift.Error)?
  public let tracingInfo: Connect.HTTPResponse.TracingInfo?
  public struct TracingInfo : Swift.Equatable, Swift.Sendable {
    public let httpStatus: Swift.Int
    public init(httpStatus: Swift.Int)
    public static func == (a: Connect.HTTPResponse.TracingInfo, b: Connect.HTTPResponse.TracingInfo) -> Swift.Bool
  }
  public init(code: Connect.Code, headers: Connect.Headers, message: Foundation.Data?, trailers: Connect.Trailers, error: (any Swift.Error)?, tracingInfo: Connect.HTTPResponse.TracingInfo?)
}
public enum IdempotencyLevel : Swift.Sendable {
  case unknown
  case noSideEffects
  case idempotent
  public static func == (a: Connect.IdempotencyLevel, b: Connect.IdempotencyLevel) -> Swift.Bool
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
public protocol Interceptor : AnyObject, Swift.Sendable {
  @Sendable func handleResponseMetrics(_ metrics: Connect.HTTPMetrics, proceed: @escaping @Sendable (Connect.HTTPMetrics) -> Swift.Void)
}
extension Connect.Interceptor {
  @Sendable public func handleResponseMetrics(_ metrics: Connect.HTTPMetrics, proceed: @escaping @Sendable (Connect.HTTPMetrics) -> Swift.Void)
}
public struct InterceptorFactory : Swift.Sendable {
  public init<T>(factory: @escaping @Sendable (Connect.ProtocolClientConfig) -> T) where T : Connect.Interceptor
}
public struct JSONCodec : Swift.Sendable {
  public init(alwaysEncodeEnumsAsInts: Swift.Bool = false, preserveProtobufFieldNames: Swift.Bool = false)
}
extension Connect.JSONCodec : Connect.Codec {
  public func name() -> Swift.String
  public func serialize<Input>(message: Input) throws -> Foundation.Data where Input : SwiftProtobuf.Message
  public func deterministicallySerialize<Input>(message: Input) throws -> Foundation.Data where Input : SwiftProtobuf.Message
  public func deserialize<Output>(source: Foundation.Data) throws -> Output where Output : SwiftProtobuf.Message
}
public struct MethodSpec : Swift.Equatable, Swift.Codable, Swift.Sendable {
  public let name: Swift.String
  public let service: Swift.String
  public let type: Connect.MethodSpec.MethodType
  public var path: Swift.String {
    get
  }
  public enum MethodType : Swift.Equatable, Swift.Codable, Swift.Sendable {
    case unary
    case clientStream
    case serverStream
    case bidirectionalStream
    public func hash(into hasher: inout Swift.Hasher)
    public static func == (a: Connect.MethodSpec.MethodType, b: Connect.MethodSpec.MethodType) -> Swift.Bool
    public func encode(to encoder: any Swift.Encoder) throws
    public var hashValue: Swift.Int {
      get
    }
    public init(from decoder: any Swift.Decoder) throws
  }
  public init(name: Swift.String, service: Swift.String, type: Connect.MethodSpec.MethodType)
  public static func == (a: Connect.MethodSpec, b: Connect.MethodSpec) -> Swift.Bool
  public func encode(to encoder: any Swift.Encoder) throws
  public init(from decoder: any Swift.Decoder) throws
}
public enum NetworkProtocol : Swift.Sendable {
  case connect
  case grpcWeb
  case custom(name: Swift.String, protocolInterceptor: Connect.InterceptorFactory)
}
extension Connect.NetworkProtocol : Swift.CustomStringConvertible {
  public var description: Swift.String {
    get
  }
}
public typealias ProtobufMessage = SwiftProtobuf.Message
public struct ProtoCodec {
  public init()
}
extension Connect.ProtoCodec : Connect.Codec {
  public func name() -> Swift.String
  public func serialize<Input>(message: Input) throws -> Foundation.Data where Input : SwiftProtobuf.Message
  public func deterministicallySerialize<Input>(message: Input) throws -> Foundation.Data where Input : SwiftProtobuf.Message
  public func deserialize<Output>(source: Foundation.Data) throws -> Output where Output : SwiftProtobuf.Message
}
final public class ProtocolClient : Swift.Sendable {
  public init(httpClient: any Connect.HTTPClientInterface = URLSessionHTTPClient(), config: Connect.ProtocolClientConfig)
  @objc deinit
}
extension Connect.ProtocolClient : Connect.ProtocolClientInterface {
  @discardableResult
  final public func unary<Input, Output>(path: Swift.String, idempotencyLevel: Connect.IdempotencyLevel, request: Input, headers: Connect.Headers, completion: @escaping @Sendable (Connect.ResponseMessage<Output>) -> Swift.Void) -> Connect.Cancelable where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  final public func bidirectionalStream<Input, Output>(path: Swift.String, headers: Connect.Headers, onResult: @escaping @Sendable (Connect.StreamResult<Output>) -> Swift.Void) -> any Connect.BidirectionalStreamInterface<Input> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  final public func clientOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers, onResult: @escaping @Sendable (Connect.StreamResult<Output>) -> Swift.Void) -> any Connect.ClientOnlyStreamInterface<Input> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  final public func serverOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers, onResult: @escaping @Sendable (Connect.StreamResult<Output>) -> Swift.Void) -> any Connect.ServerOnlyStreamInterface<Input> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  final public func unary<Input, Output>(path: Swift.String, idempotencyLevel: Connect.IdempotencyLevel, request: Input, headers: Connect.Headers) async -> Connect.ResponseMessage<Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  final public func bidirectionalStream<Input, Output>(path: Swift.String, headers: Connect.Headers) -> any Connect.BidirectionalAsyncStreamInterface<Input, Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  final public func clientOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers) -> any Connect.ClientOnlyAsyncStreamInterface<Input, Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  final public func serverOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers) -> any Connect.ServerOnlyAsyncStreamInterface<Input, Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
}
public struct ProtocolClientConfig : Swift.Sendable {
  public let unaryGET: Connect.ProtocolClientConfig.UnaryGET
  public let host: Swift.String
  public let networkProtocol: Connect.NetworkProtocol
  public let codec: any Connect.Codec
  public let requestCompression: Connect.ProtocolClientConfig.RequestCompression?
  public let responseCompressionPools: [any Connect.CompressionPool]
  public let interceptors: [Connect.InterceptorFactory]
  public let timeout: Foundation.TimeInterval?
  public struct RequestCompression : Swift.Sendable {
    public let minBytes: Swift.Int
    public let pool: any Connect.CompressionPool
    public func shouldCompress(_ data: Foundation.Data) -> Swift.Bool
    public init(minBytes: Swift.Int, pool: any Connect.CompressionPool)
  }
  public enum UnaryGET : Swift.Sendable {
    case disabled
    case alwaysEnabled
    case enabledForLimitedPayloadSizes(maxBytes: Swift.Int)
  }
  public init(host: Swift.String, networkProtocol: Connect.NetworkProtocol = .connect, codec: any Connect.Codec = JSONCodec(), unaryGET: Connect.ProtocolClientConfig.UnaryGET = .disabled, timeout: Foundation.TimeInterval? = nil, requestCompression: Connect.ProtocolClientConfig.RequestCompression? = nil, responseCompressionPools: [any Connect.CompressionPool] = [GzipCompressionPool()], interceptors: [Connect.InterceptorFactory] = [])
}
extension Connect.ProtocolClientConfig {
  public func acceptCompressionPoolNames() -> [Swift.String]
  public func responseCompressionPool(forName name: Swift.String) -> (any Connect.CompressionPool)?
}
public protocol ProtocolClientInterface : Swift.Sendable {
  @discardableResult
  func unary<Input, Output>(path: Swift.String, idempotencyLevel: Connect.IdempotencyLevel, request: Input, headers: Connect.Headers, completion: @escaping @Sendable (Connect.ResponseMessage<Output>) -> Swift.Void) -> Connect.Cancelable where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  func bidirectionalStream<Input, Output>(path: Swift.String, headers: Connect.Headers, onResult: @escaping @Sendable (Connect.StreamResult<Output>) -> Swift.Void) -> any Connect.BidirectionalStreamInterface<Input> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  func clientOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers, onResult: @escaping @Sendable (Connect.StreamResult<Output>) -> Swift.Void) -> any Connect.ClientOnlyStreamInterface<Input> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  func serverOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers, onResult: @escaping @Sendable (Connect.StreamResult<Output>) -> Swift.Void) -> any Connect.ServerOnlyStreamInterface<Input> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  func unary<Input, Output>(path: Swift.String, idempotencyLevel: Connect.IdempotencyLevel, request: Input, headers: Connect.Headers) async -> Connect.ResponseMessage<Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  func bidirectionalStream<Input, Output>(path: Swift.String, headers: Connect.Headers) -> any Connect.BidirectionalAsyncStreamInterface<Input, Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  func clientOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers) -> any Connect.ClientOnlyAsyncStreamInterface<Input, Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
  @available(iOS 13, *)
  func serverOnlyStream<Input, Output>(path: Swift.String, headers: Connect.Headers) -> any Connect.ServerOnlyAsyncStreamInterface<Input, Output> where Input : SwiftProtobuf.Message, Output : SwiftProtobuf.Message
}
final public class RequestCallbacks<T> : Swift.Sendable where T : Swift.Sendable {
  final public let cancel: @Sendable () -> Swift.Void
  final public let sendData: @Sendable (T) -> Swift.Void
  final public let sendClose: @Sendable () -> Swift.Void
  public init(cancel: @escaping @Sendable () -> Swift.Void, sendData: @escaping @Sendable (T) -> Swift.Void, sendClose: @escaping @Sendable () -> Swift.Void)
  @objc deinit
}
final public class ResponseCallbacks : Swift.Sendable {
  final public let receiveResponseHeaders: @Sendable (Connect.Headers) -> Swift.Void
  final public let receiveResponseData: @Sendable (Foundation.Data) -> Swift.Void
  final public let receiveResponseMetrics: @Sendable (Connect.HTTPMetrics) -> Swift.Void
  final public let receiveClose: @Sendable (Connect.Code, Connect.Trailers, (any Swift.Error)?) -> Swift.Void
  public init(receiveResponseHeaders: @escaping @Sendable (Connect.Headers) -> Swift.Void, receiveResponseData: @escaping @Sendable (Foundation.Data) -> Swift.Void, receiveResponseMetrics: @escaping @Sendable (Connect.HTTPMetrics) -> Swift.Void, receiveClose: @escaping @Sendable (Connect.Code, Connect.Trailers, (any Swift.Error)?) -> Swift.Void)
  @objc deinit
}
public struct ResponseMessage<Output> : Swift.Sendable where Output : SwiftProtobuf.Message {
  public let code: Connect.Code
  public let headers: Connect.Headers
  public let result: Swift.Result<Output, Connect.ConnectError>
  public let trailers: Connect.Trailers
  public var error: Connect.ConnectError? {
    get
  }
  public var message: Output? {
    get
  }
  public init(code: Connect.Code = .ok, headers: Connect.Headers = [:], result: Swift.Result<Output, Connect.ConnectError>, trailers: Connect.Trailers = [:])
}
#if compiler(>=5.3) && $PrimaryAssociatedTypes2
@available(iOS 13, *)
public protocol ServerOnlyAsyncStreamInterface<Input, Output> : Swift.Sendable {
  associatedtype Input : SwiftProtobuf.Message
  associatedtype Output : SwiftProtobuf.Message
  func send(_ input: Self.Input) throws
  func results() -> _Concurrency.AsyncStream<Connect.StreamResult<Self.Output>>
  func cancel()
}
#else
@available(iOS 13, *)
public protocol ServerOnlyAsyncStreamInterface : Swift.Sendable {
  associatedtype Input : SwiftProtobuf.Message
  associatedtype Output : SwiftProtobuf.Message
  func send(_ input: Self.Input) throws
  func results() -> _Concurrency.AsyncStream<Connect.StreamResult<Self.Output>>
  func cancel()
}
#endif
#if compiler(>=5.3) && $PrimaryAssociatedTypes2
public protocol ServerOnlyStreamInterface<Input> {
  associatedtype Input : SwiftProtobuf.Message
  func send(_ input: Self.Input)
  func cancel()
}
#else
public protocol ServerOnlyStreamInterface {
  associatedtype Input : SwiftProtobuf.Message
  func send(_ input: Self.Input)
  func cancel()
}
#endif
public protocol StreamInterceptor : Connect.Interceptor {
  @Sendable func handleStreamStart(_ request: Connect.HTTPRequest<Swift.Void>, proceed: @escaping @Sendable (Swift.Result<Connect.HTTPRequest<Swift.Void>, Connect.ConnectError>) -> Swift.Void)
  @Sendable func handleStreamInput<Message>(_ input: Message, proceed: @escaping @Sendable (Message) -> Swift.Void) where Message : SwiftProtobuf.Message
  @Sendable func handleStreamRawInput(_ input: Foundation.Data, proceed: @escaping @Sendable (Foundation.Data) -> Swift.Void)
  @Sendable func handleStreamRawResult(_ result: Connect.StreamResult<Foundation.Data>, proceed: @escaping @Sendable (Connect.StreamResult<Foundation.Data>) -> Swift.Void)
  @Sendable func handleStreamResult<Message>(_ result: Connect.StreamResult<Message>, proceed: @escaping @Sendable (Connect.StreamResult<Message>) -> Swift.Void) where Message : SwiftProtobuf.Message
}
extension Connect.StreamInterceptor {
  @Sendable public func handleStreamStart(_ request: Connect.HTTPRequest<Swift.Void>, proceed: @escaping @Sendable (Swift.Result<Connect.HTTPRequest<Swift.Void>, Connect.ConnectError>) -> Swift.Void)
  @Sendable public func handleStreamInput<Message>(_ input: Message, proceed: @escaping @Sendable (Message) -> Swift.Void) where Message : SwiftProtobuf.Message
  @Sendable public func handleStreamRawInput(_ input: Foundation.Data, proceed: @escaping @Sendable (Foundation.Data) -> Swift.Void)
  @Sendable public func handleStreamRawResult(_ result: Connect.StreamResult<Foundation.Data>, proceed: @escaping @Sendable (Connect.StreamResult<Foundation.Data>) -> Swift.Void)
  @Sendable public func handleStreamResult<Message>(_ result: Connect.StreamResult<Message>, proceed: @escaping @Sendable (Connect.StreamResult<Message>) -> Swift.Void) where Message : SwiftProtobuf.Message
}
@frozen public enum StreamResult<Output> : Swift.Sendable where Output : Swift.Sendable {
  case complete(code: Connect.Code, error: (any Swift.Error)?, trailers: Connect.Trailers?)
  case headers(Connect.Headers)
  case message(Output)
  public var messageValue: Output? {
    get
  }
}
extension Connect.StreamResult : Swift.Equatable where Output : Swift.Equatable {
  public static func == (lhs: Connect.StreamResult<Output>, rhs: Connect.StreamResult<Output>) -> Swift.Bool
}
public typealias Trailers = [Swift.String : [Swift.String]]
extension Swift.Dictionary where Key == Swift.String, Value == [Swift.String] {
  @available(swift, deprecated: 100.0, message: "This is an internal-only API which will be made package-private in Swift 6.")
  public func _grpcStatus() -> Connect.Code?
}
public protocol UnaryInterceptor : Connect.Interceptor {
  @Sendable func handleUnaryRequest<Message>(_ request: Connect.HTTPRequest<Message>, proceed: @escaping @Sendable (Swift.Result<Connect.HTTPRequest<Message>, Connect.ConnectError>) -> Swift.Void) where Message : SwiftProtobuf.Message
  @Sendable func handleUnaryRawRequest(_ request: Connect.HTTPRequest<Foundation.Data?>, proceed: @escaping @Sendable (Swift.Result<Connect.HTTPRequest<Foundation.Data?>, Connect.ConnectError>) -> Swift.Void)
  @Sendable func handleUnaryRawResponse(_ response: Connect.HTTPResponse, proceed: @escaping @Sendable (Connect.HTTPResponse) -> Swift.Void)
  @Sendable func handleUnaryResponse<Message>(_ response: Connect.ResponseMessage<Message>, proceed: @escaping @Sendable (Connect.ResponseMessage<Message>) -> Swift.Void) where Message : SwiftProtobuf.Message
}
extension Connect.UnaryInterceptor {
  @Sendable public func handleUnaryRequest<Message>(_ request: Connect.HTTPRequest<Message>, proceed: @escaping @Sendable (Swift.Result<Connect.HTTPRequest<Message>, Connect.ConnectError>) -> Swift.Void) where Message : SwiftProtobuf.Message
  @Sendable public func handleUnaryRawRequest(_ request: Connect.HTTPRequest<Foundation.Data?>, proceed: @escaping @Sendable (Swift.Result<Connect.HTTPRequest<Foundation.Data?>, Connect.ConnectError>) -> Swift.Void)
  @Sendable public func handleUnaryRawResponse(_ response: Connect.HTTPResponse, proceed: @escaping @Sendable (Connect.HTTPResponse) -> Swift.Void)
  @Sendable public func handleUnaryResponse<Message>(_ response: Connect.ResponseMessage<Message>, proceed: @escaping @Sendable (Connect.ResponseMessage<Message>) -> Swift.Void) where Message : SwiftProtobuf.Message
}
@objc open class URLSessionHTTPClient : ObjectiveC.NSObject, Connect.HTTPClientInterface, @unchecked Swift.Sendable {
  public init(configuration: Foundation.URLSessionConfiguration = .default)
  @discardableResult
  open func unary(request: Connect.HTTPRequest<Foundation.Data?>, onMetrics: @escaping @Sendable (Connect.HTTPMetrics) -> Swift.Void, onResponse: @escaping @Sendable (Connect.HTTPResponse) -> Swift.Void) -> Connect.Cancelable
  open func stream(request: Connect.HTTPRequest<Foundation.Data?>, responseCallbacks: Connect.ResponseCallbacks) -> Connect.RequestCallbacks<Foundation.Data>
  @objc deinit
}
extension Connect.URLSessionHTTPClient : Foundation.URLSessionDataDelegate {
  @objc dynamic open func urlSession(_ session: Foundation.URLSession, dataTask: Foundation.URLSessionDataTask, didReceive response: Foundation.URLResponse, completionHandler: @escaping (Foundation.URLSession.ResponseDisposition) -> Swift.Void)
  @objc dynamic open func urlSession(_ session: Foundation.URLSession, dataTask: Foundation.URLSessionDataTask, didReceive data: Foundation.Data)
  @objc dynamic open func urlSession(_ session: Foundation.URLSession, task: Foundation.URLSessionTask, needNewBodyStream completionHandler: @escaping (Foundation.InputStream?) -> Swift.Void)
}
extension Connect.URLSessionHTTPClient : Foundation.URLSessionTaskDelegate {
  @objc dynamic open func urlSession(_ session: Foundation.URLSession, task: Foundation.URLSessionTask, didCompleteWithError error: (any Swift.Error)?)
  @objc dynamic open func urlSession(_ session: Foundation.URLSession, task: Foundation.URLSessionTask, didFinishCollecting metrics: Foundation.URLSessionTaskMetrics)
}
extension Connect.Code : Swift.Hashable {}
extension Connect.Code : Swift.RawRepresentable {}
extension Connect.GzipCompressionPool.GzipError : Swift.Equatable {}
extension Connect.GzipCompressionPool.GzipError : Swift.Hashable {}
extension Connect.HTTPMethod : Swift.Equatable {}
extension Connect.HTTPMethod : Swift.Hashable {}
extension Connect.HTTPMethod : Swift.RawRepresentable {}
extension Connect.IdempotencyLevel : Swift.Equatable {}
extension Connect.IdempotencyLevel : Swift.Hashable {}
extension Connect.MethodSpec.MethodType : Swift.Hashable {}