941 lines
35 KiB
Swift
941 lines
35 KiB
Swift
// Code generated by tools/generate.py; DO NOT EDIT.
|
|
import Foundation
|
|
public typealias JSONObject = [String: String]
|
|
public let schemaSHA256 = "b8a69785112bb94d45f47c2250ca59d0bde47e3667b8ad89c9b0e2c4cfb25aec"
|
|
public let currentWireVersion = "1"
|
|
public let nMinus1WireVersion = "0"
|
|
public let nMinus2WireVersion = "-1"
|
|
|
|
public struct AllocationPolicy: Codable, Equatable {
|
|
public let minimumKbps: Int64
|
|
public let targetKbps: Int64
|
|
public let maximumKbps: Int64
|
|
public let tier: String
|
|
public let audience: String
|
|
public let protocolValue: String
|
|
public let protocolVersion: Int64
|
|
public let grantTtlSeconds: Int64
|
|
public let reservationLeaseSeconds: Int64
|
|
enum CodingKeys: String, CodingKey {
|
|
case minimumKbps = "minimum_kbps"
|
|
case targetKbps = "target_kbps"
|
|
case maximumKbps = "maximum_kbps"
|
|
case tier = "tier"
|
|
case audience = "audience"
|
|
case protocolValue = "protocol"
|
|
case protocolVersion = "protocol_version"
|
|
case grantTtlSeconds = "grant_ttl_seconds"
|
|
case reservationLeaseSeconds = "reservation_lease_seconds"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
minimumKbps = try c.decode(Int64.self, forKey: .minimumKbps)
|
|
targetKbps = try c.decode(Int64.self, forKey: .targetKbps)
|
|
maximumKbps = try c.decode(Int64.self, forKey: .maximumKbps)
|
|
tier = try c.decode(String.self, forKey: .tier)
|
|
audience = try c.decode(String.self, forKey: .audience)
|
|
protocolValue = try c.decode(String.self, forKey: .protocolValue)
|
|
protocolVersion = try c.decode(Int64.self, forKey: .protocolVersion)
|
|
grantTtlSeconds = try c.decode(Int64.self, forKey: .grantTtlSeconds)
|
|
reservationLeaseSeconds = try c.decode(Int64.self, forKey: .reservationLeaseSeconds)
|
|
}
|
|
}
|
|
|
|
public struct AssignedDesktop: Codable, Equatable {
|
|
public let assignmentId: String
|
|
public let poolId: String
|
|
public let name: String
|
|
public let availability: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case assignmentId = "assignment_id"
|
|
case poolId = "pool_id"
|
|
case name = "name"
|
|
case availability = "availability"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
assignmentId = try c.decode(String.self, forKey: .assignmentId)
|
|
poolId = try c.decode(String.self, forKey: .poolId)
|
|
name = try c.decode(String.self, forKey: .name)
|
|
availability = try c.decode(String.self, forKey: .availability)
|
|
}
|
|
}
|
|
|
|
public struct BrokerSession: Codable, Equatable {
|
|
public let id: String
|
|
public let principalId: String
|
|
public let poolId: String
|
|
public let assignmentId: String?
|
|
public let state: String
|
|
public let policySnapshot: AllocationPolicy
|
|
public let reconnectDeadline: String?
|
|
public let outcome: String?
|
|
public let failureCode: String?
|
|
public let cleanupState: String
|
|
public let idempotencyKey: String
|
|
public let correlationId: String
|
|
public let requestedAt: String
|
|
public let endedAt: String?
|
|
public let version: Int64
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
case principalId = "principal_id"
|
|
case poolId = "pool_id"
|
|
case assignmentId = "assignment_id"
|
|
case state = "state"
|
|
case policySnapshot = "policy_snapshot"
|
|
case reconnectDeadline = "reconnect_deadline"
|
|
case outcome = "outcome"
|
|
case failureCode = "failure_code"
|
|
case cleanupState = "cleanup_state"
|
|
case idempotencyKey = "idempotency_key"
|
|
case correlationId = "correlation_id"
|
|
case requestedAt = "requested_at"
|
|
case endedAt = "ended_at"
|
|
case version = "version"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
id = try c.decode(String.self, forKey: .id)
|
|
principalId = try c.decode(String.self, forKey: .principalId)
|
|
poolId = try c.decode(String.self, forKey: .poolId)
|
|
assignmentId = try c.decodeIfPresent(String.self, forKey: .assignmentId)
|
|
state = try c.decode(String.self, forKey: .state)
|
|
policySnapshot = try c.decode(AllocationPolicy.self, forKey: .policySnapshot)
|
|
reconnectDeadline = try c.decodeIfPresent(String.self, forKey: .reconnectDeadline)
|
|
outcome = try c.decodeIfPresent(String.self, forKey: .outcome)
|
|
failureCode = try c.decodeIfPresent(String.self, forKey: .failureCode)
|
|
cleanupState = try c.decode(String.self, forKey: .cleanupState)
|
|
idempotencyKey = try c.decode(String.self, forKey: .idempotencyKey)
|
|
correlationId = try c.decode(String.self, forKey: .correlationId)
|
|
requestedAt = try c.decode(String.self, forKey: .requestedAt)
|
|
endedAt = try c.decodeIfPresent(String.self, forKey: .endedAt)
|
|
version = try c.decode(Int64.self, forKey: .version)
|
|
}
|
|
}
|
|
|
|
public struct CapabilityProfile: Codable, Equatable {
|
|
public let transport: String
|
|
public let framing: String
|
|
public let media: String
|
|
public let audio: String
|
|
public let sourceRateControl: String
|
|
public let clientDecode: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case transport = "transport"
|
|
case framing = "framing"
|
|
case media = "media"
|
|
case audio = "audio"
|
|
case sourceRateControl = "source_rate_control"
|
|
case clientDecode = "client_decode"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
transport = try c.decode(String.self, forKey: .transport)
|
|
framing = try c.decode(String.self, forKey: .framing)
|
|
media = try c.decode(String.self, forKey: .media)
|
|
audio = try c.decode(String.self, forKey: .audio)
|
|
sourceRateControl = try c.decode(String.self, forKey: .sourceRateControl)
|
|
clientDecode = try c.decode(String.self, forKey: .clientDecode)
|
|
}
|
|
}
|
|
|
|
public struct ChannelFrame: Codable, Equatable {
|
|
public let version: String
|
|
public let flowId: String
|
|
public let sequence: Int64
|
|
public let flags: Int64
|
|
public let fragmentIndex: Int64
|
|
public let fragmentCount: Int64
|
|
public let timestampMs: Int64
|
|
public let payload: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case flowId = "flow_id"
|
|
case sequence = "sequence"
|
|
case flags = "flags"
|
|
case fragmentIndex = "fragment_index"
|
|
case fragmentCount = "fragment_count"
|
|
case timestampMs = "timestamp_ms"
|
|
case payload = "payload"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
flowId = try c.decode(String.self, forKey: .flowId)
|
|
sequence = try c.decode(Int64.self, forKey: .sequence)
|
|
flags = try c.decode(Int64.self, forKey: .flags)
|
|
fragmentIndex = try c.decode(Int64.self, forKey: .fragmentIndex)
|
|
fragmentCount = try c.decode(Int64.self, forKey: .fragmentCount)
|
|
timestampMs = try c.decode(Int64.self, forKey: .timestampMs)
|
|
payload = try c.decode(String.self, forKey: .payload)
|
|
}
|
|
}
|
|
|
|
public struct ClipboardText: Codable, Equatable {
|
|
public let text: String
|
|
public let encoding: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case text = "text"
|
|
case encoding = "encoding"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
text = try c.decode(String.self, forKey: .text)
|
|
encoding = try c.decode(String.self, forKey: .encoding)
|
|
}
|
|
}
|
|
|
|
public struct ConnectionManifest: Codable, Equatable {
|
|
public let version: String
|
|
public let purpose: String
|
|
public let sessionId: String
|
|
public let reconnectSequence: Int64
|
|
public let gateway: ManifestGateway
|
|
public let tunnel: ManifestTunnel
|
|
public let profile: ManifestProfile
|
|
public let grant: GrantReference
|
|
public let correlationId: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case purpose = "purpose"
|
|
case sessionId = "session_id"
|
|
case reconnectSequence = "reconnect_sequence"
|
|
case gateway = "gateway"
|
|
case tunnel = "tunnel"
|
|
case profile = "profile"
|
|
case grant = "grant"
|
|
case correlationId = "correlation_id"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
purpose = try c.decode(String.self, forKey: .purpose)
|
|
sessionId = try c.decode(String.self, forKey: .sessionId)
|
|
reconnectSequence = try c.decode(Int64.self, forKey: .reconnectSequence)
|
|
gateway = try c.decode(ManifestGateway.self, forKey: .gateway)
|
|
tunnel = try c.decode(ManifestTunnel.self, forKey: .tunnel)
|
|
profile = try c.decode(ManifestProfile.self, forKey: .profile)
|
|
grant = try c.decode(GrantReference.self, forKey: .grant)
|
|
correlationId = try c.decode(String.self, forKey: .correlationId)
|
|
}
|
|
}
|
|
|
|
public struct DeviceChallenge: Codable, Equatable {
|
|
public let deviceId: String
|
|
public let serverId: String
|
|
public let principalId: String
|
|
public let challenge: String
|
|
public let expiresAt: String
|
|
public let algorithm: String
|
|
public let signatureFormat: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case deviceId = "device_id"
|
|
case serverId = "server_id"
|
|
case principalId = "principal_id"
|
|
case challenge = "challenge"
|
|
case expiresAt = "expires_at"
|
|
case algorithm = "algorithm"
|
|
case signatureFormat = "signature_format"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
deviceId = try c.decode(String.self, forKey: .deviceId)
|
|
serverId = try c.decode(String.self, forKey: .serverId)
|
|
principalId = try c.decode(String.self, forKey: .principalId)
|
|
challenge = try c.decode(String.self, forKey: .challenge)
|
|
expiresAt = try c.decode(String.self, forKey: .expiresAt)
|
|
algorithm = try c.decode(String.self, forKey: .algorithm)
|
|
signatureFormat = try c.decode(String.self, forKey: .signatureFormat)
|
|
}
|
|
}
|
|
|
|
public struct DeviceProofRequest: Codable, Equatable {
|
|
public let challenge: String
|
|
public let signature: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case challenge = "challenge"
|
|
case signature = "signature"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
challenge = try c.decode(String.self, forKey: .challenge)
|
|
signature = try c.decode(String.self, forKey: .signature)
|
|
}
|
|
}
|
|
|
|
public struct DeviceRegistrationRequest: Codable, Equatable {
|
|
public let name: String
|
|
public let platform: String
|
|
public let deviceSubject: String
|
|
public let algorithm: String
|
|
public let publicKey: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case name = "name"
|
|
case platform = "platform"
|
|
case deviceSubject = "device_subject"
|
|
case algorithm = "algorithm"
|
|
case publicKey = "public_key"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
name = try c.decode(String.self, forKey: .name)
|
|
platform = try c.decode(String.self, forKey: .platform)
|
|
deviceSubject = try c.decode(String.self, forKey: .deviceSubject)
|
|
algorithm = try c.decode(String.self, forKey: .algorithm)
|
|
publicKey = try c.decode(String.self, forKey: .publicKey)
|
|
}
|
|
}
|
|
|
|
public struct EntitledPool: Codable, Equatable {
|
|
public let poolId: String
|
|
public let name: String
|
|
public let assignmentState: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case poolId = "pool_id"
|
|
case name = "name"
|
|
case assignmentState = "assignment_state"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
poolId = try c.decode(String.self, forKey: .poolId)
|
|
name = try c.decode(String.self, forKey: .name)
|
|
assignmentState = try c.decode(String.self, forKey: .assignmentState)
|
|
}
|
|
}
|
|
|
|
public struct ErrorEnvelope: Codable, Equatable {
|
|
public let status: Bool
|
|
public let error: String
|
|
public let code: String
|
|
public let message: String
|
|
public let resolution: String
|
|
public let requestId: String
|
|
public let violations: [FieldViolation]
|
|
enum CodingKeys: String, CodingKey {
|
|
case status = "status"
|
|
case error = "error"
|
|
case code = "code"
|
|
case message = "message"
|
|
case resolution = "resolution"
|
|
case requestId = "request_id"
|
|
case violations = "violations"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
status = try c.decode(Bool.self, forKey: .status)
|
|
error = try c.decode(String.self, forKey: .error)
|
|
code = try c.decode(String.self, forKey: .code)
|
|
message = try c.decode(String.self, forKey: .message)
|
|
resolution = try c.decode(String.self, forKey: .resolution)
|
|
requestId = try c.decode(String.self, forKey: .requestId)
|
|
violations = try c.decode([FieldViolation].self, forKey: .violations)
|
|
}
|
|
}
|
|
|
|
public struct EventEnvelope: Codable, Equatable {
|
|
public let eventId: String
|
|
public let sequence: Int64
|
|
public let type: String
|
|
public let version: Int64
|
|
public let resource: ResourceLink
|
|
public let occurredAt: String
|
|
public let correlationId: String
|
|
public let payload: JSONObject
|
|
enum CodingKeys: String, CodingKey {
|
|
case eventId = "event_id"
|
|
case sequence = "sequence"
|
|
case type = "type"
|
|
case version = "version"
|
|
case resource = "resource"
|
|
case occurredAt = "occurred_at"
|
|
case correlationId = "correlation_id"
|
|
case payload = "payload"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
eventId = try c.decode(String.self, forKey: .eventId)
|
|
sequence = try c.decode(Int64.self, forKey: .sequence)
|
|
type = try c.decode(String.self, forKey: .type)
|
|
version = try c.decode(Int64.self, forKey: .version)
|
|
resource = try c.decode(ResourceLink.self, forKey: .resource)
|
|
occurredAt = try c.decode(String.self, forKey: .occurredAt)
|
|
correlationId = try c.decode(String.self, forKey: .correlationId)
|
|
payload = try c.decode(JSONObject.self, forKey: .payload)
|
|
}
|
|
}
|
|
|
|
public struct EventResume: Codable, Equatable {
|
|
public let cursor: String
|
|
public let lastSequence: Int64
|
|
enum CodingKeys: String, CodingKey {
|
|
case cursor = "cursor"
|
|
case lastSequence = "last_sequence"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
cursor = try c.decode(String.self, forKey: .cursor)
|
|
lastSequence = try c.decode(Int64.self, forKey: .lastSequence)
|
|
}
|
|
}
|
|
|
|
public struct FieldViolation: Codable, Equatable {
|
|
public let field: String
|
|
public let code: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case field = "field"
|
|
case code = "code"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
field = try c.decode(String.self, forKey: .field)
|
|
code = try c.decode(String.self, forKey: .code)
|
|
}
|
|
}
|
|
|
|
public struct GatewayDrain: Codable, Equatable {
|
|
public let version: String
|
|
public let gatewayId: String
|
|
public let sequence: Int64
|
|
public let reason: String
|
|
public let deadline: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case gatewayId = "gateway_id"
|
|
case sequence = "sequence"
|
|
case reason = "reason"
|
|
case deadline = "deadline"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
gatewayId = try c.decode(String.self, forKey: .gatewayId)
|
|
sequence = try c.decode(Int64.self, forKey: .sequence)
|
|
reason = try c.decode(String.self, forKey: .reason)
|
|
deadline = try c.decode(String.self, forKey: .deadline)
|
|
}
|
|
}
|
|
|
|
public struct GatewayHeartbeat: Codable, Equatable {
|
|
public let version: String
|
|
public let gatewayId: String
|
|
public let sequence: Int64
|
|
public let observedAt: String
|
|
public let activeConnections: Int64
|
|
public let egressKbps: Int64
|
|
public let state: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case gatewayId = "gateway_id"
|
|
case sequence = "sequence"
|
|
case observedAt = "observed_at"
|
|
case activeConnections = "active_connections"
|
|
case egressKbps = "egress_kbps"
|
|
case state = "state"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
gatewayId = try c.decode(String.self, forKey: .gatewayId)
|
|
sequence = try c.decode(Int64.self, forKey: .sequence)
|
|
observedAt = try c.decode(String.self, forKey: .observedAt)
|
|
activeConnections = try c.decode(Int64.self, forKey: .activeConnections)
|
|
egressKbps = try c.decode(Int64.self, forKey: .egressKbps)
|
|
state = try c.decode(String.self, forKey: .state)
|
|
}
|
|
}
|
|
|
|
public struct GatewayRegistration: Codable, Equatable {
|
|
public let version: String
|
|
public let gatewayId: String
|
|
public let instanceIdentity: String
|
|
public let certificateIdentity: String
|
|
public let publicIdentity: String
|
|
public let address: String
|
|
public let providerIdentity: String
|
|
public let protocolMinVersion: Int64
|
|
public let protocolMaxVersion: Int64
|
|
public let connectionCapacity: Int64
|
|
public let bandwidthCapacityKbps: Int64
|
|
public let features: [String]
|
|
public let capabilities: CapabilityProfile
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case gatewayId = "gateway_id"
|
|
case instanceIdentity = "instance_identity"
|
|
case certificateIdentity = "certificate_identity"
|
|
case publicIdentity = "public_identity"
|
|
case address = "address"
|
|
case providerIdentity = "provider_identity"
|
|
case protocolMinVersion = "protocol_min_version"
|
|
case protocolMaxVersion = "protocol_max_version"
|
|
case connectionCapacity = "connection_capacity"
|
|
case bandwidthCapacityKbps = "bandwidth_capacity_kbps"
|
|
case features = "features"
|
|
case capabilities = "capabilities"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
gatewayId = try c.decode(String.self, forKey: .gatewayId)
|
|
instanceIdentity = try c.decode(String.self, forKey: .instanceIdentity)
|
|
certificateIdentity = try c.decode(String.self, forKey: .certificateIdentity)
|
|
publicIdentity = try c.decode(String.self, forKey: .publicIdentity)
|
|
address = try c.decode(String.self, forKey: .address)
|
|
providerIdentity = try c.decode(String.self, forKey: .providerIdentity)
|
|
protocolMinVersion = try c.decode(Int64.self, forKey: .protocolMinVersion)
|
|
protocolMaxVersion = try c.decode(Int64.self, forKey: .protocolMaxVersion)
|
|
connectionCapacity = try c.decode(Int64.self, forKey: .connectionCapacity)
|
|
bandwidthCapacityKbps = try c.decode(Int64.self, forKey: .bandwidthCapacityKbps)
|
|
features = try c.decode([String].self, forKey: .features)
|
|
capabilities = try c.decode(CapabilityProfile.self, forKey: .capabilities)
|
|
}
|
|
}
|
|
|
|
public struct GrantReference: Codable, Equatable {
|
|
public let opaqueValue: String
|
|
public let expiresAt: String
|
|
public let audience: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case opaqueValue = "opaque_value"
|
|
case expiresAt = "expires_at"
|
|
case audience = "audience"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
opaqueValue = try c.decode(String.self, forKey: .opaqueValue)
|
|
expiresAt = try c.decode(String.self, forKey: .expiresAt)
|
|
audience = try c.decode(String.self, forKey: .audience)
|
|
}
|
|
}
|
|
|
|
public struct LoginRequest: Codable, Equatable {
|
|
public let provider: String?
|
|
public let username: String
|
|
public let password: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case provider = "provider"
|
|
case username = "username"
|
|
case password = "password"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
provider = try c.decodeIfPresent(String.self, forKey: .provider)
|
|
username = try c.decode(String.self, forKey: .username)
|
|
password = try c.decode(String.self, forKey: .password)
|
|
}
|
|
}
|
|
|
|
public struct ManifestBounds: Codable, Equatable {
|
|
public let minimumKbps: Int64
|
|
public let targetKbps: Int64
|
|
public let maximumKbps: Int64
|
|
enum CodingKeys: String, CodingKey {
|
|
case minimumKbps = "minimum_kbps"
|
|
case targetKbps = "target_kbps"
|
|
case maximumKbps = "maximum_kbps"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
minimumKbps = try c.decode(Int64.self, forKey: .minimumKbps)
|
|
targetKbps = try c.decode(Int64.self, forKey: .targetKbps)
|
|
maximumKbps = try c.decode(Int64.self, forKey: .maximumKbps)
|
|
}
|
|
}
|
|
|
|
public struct ManifestGateway: Codable, Equatable {
|
|
public let id: String
|
|
public let addresses: [String]
|
|
public let publicIdentity: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
case addresses = "addresses"
|
|
case publicIdentity = "public_identity"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
id = try c.decode(String.self, forKey: .id)
|
|
addresses = try c.decode([String].self, forKey: .addresses)
|
|
publicIdentity = try c.decode(String.self, forKey: .publicIdentity)
|
|
}
|
|
}
|
|
|
|
public struct ManifestProfile: Codable, Equatable {
|
|
public let id: String
|
|
public let bounds: ManifestBounds
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
case bounds = "bounds"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
id = try c.decode(String.self, forKey: .id)
|
|
bounds = try c.decode(ManifestBounds.self, forKey: .bounds)
|
|
}
|
|
}
|
|
|
|
public struct ManifestTunnel: Codable, Equatable {
|
|
public let versions: [String]
|
|
public let features: [String]
|
|
enum CodingKeys: String, CodingKey {
|
|
case versions = "versions"
|
|
case features = "features"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
versions = try c.decode([String].self, forKey: .versions)
|
|
features = try c.decode([String].self, forKey: .features)
|
|
}
|
|
}
|
|
|
|
public struct NativeCredential: Codable, Equatable {
|
|
public let deviceId: String?
|
|
public let familyId: String
|
|
public let accessToken: String
|
|
public let refreshToken: String
|
|
public let expiresAt: String
|
|
public let refreshExpiresAt: String?
|
|
enum CodingKeys: String, CodingKey {
|
|
case deviceId = "device_id"
|
|
case familyId = "family_id"
|
|
case accessToken = "access_token"
|
|
case refreshToken = "refresh_token"
|
|
case expiresAt = "expires_at"
|
|
case refreshExpiresAt = "refresh_expires_at"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
deviceId = try c.decodeIfPresent(String.self, forKey: .deviceId)
|
|
familyId = try c.decode(String.self, forKey: .familyId)
|
|
accessToken = try c.decode(String.self, forKey: .accessToken)
|
|
refreshToken = try c.decode(String.self, forKey: .refreshToken)
|
|
expiresAt = try c.decode(String.self, forKey: .expiresAt)
|
|
refreshExpiresAt = try c.decodeIfPresent(String.self, forKey: .refreshExpiresAt)
|
|
}
|
|
}
|
|
|
|
public struct PageInfo: Codable, Equatable {
|
|
public let limit: Int64
|
|
public let nextCursor: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case limit = "limit"
|
|
case nextCursor = "next_cursor"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
limit = try c.decode(Int64.self, forKey: .limit)
|
|
nextCursor = try c.decode(String.self, forKey: .nextCursor)
|
|
}
|
|
}
|
|
|
|
public struct ProviderState: Codable, Equatable {
|
|
public let version: String
|
|
public let sessionId: String
|
|
public let state: String
|
|
public let cleanupPending: Bool
|
|
public let channels: [String]
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case sessionId = "session_id"
|
|
case state = "state"
|
|
case cleanupPending = "cleanup_pending"
|
|
case channels = "channels"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
sessionId = try c.decode(String.self, forKey: .sessionId)
|
|
state = try c.decode(String.self, forKey: .state)
|
|
cleanupPending = try c.decode(Bool.self, forKey: .cleanupPending)
|
|
channels = try c.decode([String].self, forKey: .channels)
|
|
}
|
|
}
|
|
|
|
public struct ReauthGrant: Codable, Equatable {
|
|
public let token: String
|
|
public let purpose: String
|
|
public let expiresAt: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case token = "token"
|
|
case purpose = "purpose"
|
|
case expiresAt = "expires_at"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
token = try c.decode(String.self, forKey: .token)
|
|
purpose = try c.decode(String.self, forKey: .purpose)
|
|
expiresAt = try c.decode(String.self, forKey: .expiresAt)
|
|
}
|
|
}
|
|
|
|
public struct ReauthRequest: Codable, Equatable {
|
|
public let password: String
|
|
public let purpose: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case password = "password"
|
|
case purpose = "purpose"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
password = try c.decode(String.self, forKey: .password)
|
|
purpose = try c.decode(String.self, forKey: .purpose)
|
|
}
|
|
}
|
|
|
|
public struct ReconnectRequest: Codable, Equatable {
|
|
public let clientDeviceId: String
|
|
public let deviceKeyId: String
|
|
public let expectedVersion: Int64
|
|
enum CodingKeys: String, CodingKey {
|
|
case clientDeviceId = "client_device_id"
|
|
case deviceKeyId = "device_key_id"
|
|
case expectedVersion = "expected_version"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
clientDeviceId = try c.decode(String.self, forKey: .clientDeviceId)
|
|
deviceKeyId = try c.decode(String.self, forKey: .deviceKeyId)
|
|
expectedVersion = try c.decode(Int64.self, forKey: .expectedVersion)
|
|
}
|
|
}
|
|
|
|
public struct RefreshRequest: Codable, Equatable {
|
|
public let familyId: String
|
|
public let refreshToken: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case familyId = "family_id"
|
|
case refreshToken = "refresh_token"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
familyId = try c.decode(String.self, forKey: .familyId)
|
|
refreshToken = try c.decode(String.self, forKey: .refreshToken)
|
|
}
|
|
}
|
|
|
|
public struct Resource: Codable, Equatable {
|
|
public let id: String
|
|
public let kind: String
|
|
public let name: String
|
|
public let state: String
|
|
public let assignmentState: String?
|
|
public let version: Int64
|
|
public let links: [ResourceLink]
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
case kind = "kind"
|
|
case name = "name"
|
|
case state = "state"
|
|
case assignmentState = "assignment_state"
|
|
case version = "version"
|
|
case links = "links"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
id = try c.decode(String.self, forKey: .id)
|
|
kind = try c.decode(String.self, forKey: .kind)
|
|
name = try c.decode(String.self, forKey: .name)
|
|
state = try c.decode(String.self, forKey: .state)
|
|
assignmentState = try c.decodeIfPresent(String.self, forKey: .assignmentState)
|
|
version = try c.decode(Int64.self, forKey: .version)
|
|
links = try c.decode([ResourceLink].self, forKey: .links)
|
|
}
|
|
}
|
|
|
|
public struct ResourceLink: Codable, Equatable {
|
|
public let type: String
|
|
public let id: String
|
|
public let version: Int64
|
|
enum CodingKeys: String, CodingKey {
|
|
case type = "type"
|
|
case id = "id"
|
|
case version = "version"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
type = try c.decode(String.self, forKey: .type)
|
|
id = try c.decode(String.self, forKey: .id)
|
|
version = try c.decode(Int64.self, forKey: .version)
|
|
}
|
|
}
|
|
|
|
public struct ResourceList: Codable, Equatable {
|
|
public let assignedDesktops: [AssignedDesktop]
|
|
public let entitledPools: [EntitledPool]
|
|
public let page: PageInfo
|
|
enum CodingKeys: String, CodingKey {
|
|
case assignedDesktops = "assigned_desktops"
|
|
case entitledPools = "entitled_pools"
|
|
case page = "page"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
assignedDesktops = try c.decode([AssignedDesktop].self, forKey: .assignedDesktops)
|
|
entitledPools = try c.decode([EntitledPool].self, forKey: .entitledPools)
|
|
page = try c.decode(PageInfo.self, forKey: .page)
|
|
}
|
|
}
|
|
|
|
public struct SessionAuthority: Codable, Equatable {
|
|
public let version: String
|
|
public let sessionId: String
|
|
public let gatewayId: String
|
|
public let audience: String
|
|
public let reconnectSequence: Int64
|
|
public let expiresAt: String
|
|
public let capabilities: CapabilityProfile
|
|
public let providerProfile: String
|
|
public let providerIdentity: String
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case sessionId = "session_id"
|
|
case gatewayId = "gateway_id"
|
|
case audience = "audience"
|
|
case reconnectSequence = "reconnect_sequence"
|
|
case expiresAt = "expires_at"
|
|
case capabilities = "capabilities"
|
|
case providerProfile = "provider_profile"
|
|
case providerIdentity = "provider_identity"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
sessionId = try c.decode(String.self, forKey: .sessionId)
|
|
gatewayId = try c.decode(String.self, forKey: .gatewayId)
|
|
audience = try c.decode(String.self, forKey: .audience)
|
|
reconnectSequence = try c.decode(Int64.self, forKey: .reconnectSequence)
|
|
expiresAt = try c.decode(String.self, forKey: .expiresAt)
|
|
capabilities = try c.decode(CapabilityProfile.self, forKey: .capabilities)
|
|
providerProfile = try c.decode(String.self, forKey: .providerProfile)
|
|
providerIdentity = try c.decode(String.self, forKey: .providerIdentity)
|
|
}
|
|
}
|
|
|
|
public struct SessionRequest: Codable, Equatable {
|
|
public let clientDeviceId: String
|
|
public let deviceKeyId: String
|
|
public let poolId: String
|
|
public let idempotencyKey: String
|
|
public let policySnapshot: AllocationPolicy
|
|
enum CodingKeys: String, CodingKey {
|
|
case clientDeviceId = "client_device_id"
|
|
case deviceKeyId = "device_key_id"
|
|
case poolId = "pool_id"
|
|
case idempotencyKey = "idempotency_key"
|
|
case policySnapshot = "policy_snapshot"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
clientDeviceId = try c.decode(String.self, forKey: .clientDeviceId)
|
|
deviceKeyId = try c.decode(String.self, forKey: .deviceKeyId)
|
|
poolId = try c.decode(String.self, forKey: .poolId)
|
|
idempotencyKey = try c.decode(String.self, forKey: .idempotencyKey)
|
|
policySnapshot = try c.decode(AllocationPolicy.self, forKey: .policySnapshot)
|
|
}
|
|
}
|
|
|
|
public struct StableError: Codable, Equatable {
|
|
public let version: String
|
|
public let code: String
|
|
public let message: String
|
|
public let retryable: Bool
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case code = "code"
|
|
case message = "message"
|
|
case retryable = "retryable"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
code = try c.decode(String.self, forKey: .code)
|
|
message = try c.decode(String.self, forKey: .message)
|
|
retryable = try c.decode(Bool.self, forKey: .retryable)
|
|
}
|
|
}
|
|
|
|
public struct TunnelAdmissionRequest: Codable, Equatable {
|
|
public let version: String
|
|
public let sessionId: String
|
|
public let gatewayId: String
|
|
public let audience: String
|
|
public let grant: String
|
|
public let reconnectSequence: Int64
|
|
public let clientNonce: String
|
|
public let capabilities: CapabilityProfile
|
|
enum CodingKeys: String, CodingKey {
|
|
case version = "version"
|
|
case sessionId = "session_id"
|
|
case gatewayId = "gateway_id"
|
|
case audience = "audience"
|
|
case grant = "grant"
|
|
case reconnectSequence = "reconnect_sequence"
|
|
case clientNonce = "client_nonce"
|
|
case capabilities = "capabilities"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
version = try c.decode(String.self, forKey: .version)
|
|
sessionId = try c.decode(String.self, forKey: .sessionId)
|
|
gatewayId = try c.decode(String.self, forKey: .gatewayId)
|
|
audience = try c.decode(String.self, forKey: .audience)
|
|
grant = try c.decode(String.self, forKey: .grant)
|
|
reconnectSequence = try c.decode(Int64.self, forKey: .reconnectSequence)
|
|
clientNonce = try c.decode(String.self, forKey: .clientNonce)
|
|
capabilities = try c.decode(CapabilityProfile.self, forKey: .capabilities)
|
|
}
|
|
}
|
|
|
|
public struct VersionNegotiation: Codable, Equatable {
|
|
public let supportedVersions: [String]
|
|
public let features: [String]
|
|
enum CodingKeys: String, CodingKey {
|
|
case supportedVersions = "supported_versions"
|
|
case features = "features"
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
supportedVersions = try c.decode([String].self, forKey: .supportedVersions)
|
|
features = try c.decode([String].self, forKey: .features)
|
|
}
|
|
}
|