1913 lines
117 KiB
Swift
1913 lines
117 KiB
Swift
// Code generated by tools/generate.py; DO NOT EDIT.
|
|
import Foundation
|
|
public typealias JSONObject = [String: String]
|
|
public let schemaSHA256 = "6b8631bf2b2aa12b14d0bc4d136af39a632e85b3237dc5614469ba09d93f5fca"
|
|
public let currentWireVersion = "1"
|
|
public let nMinus1WireVersion = "0"
|
|
public let nMinus2WireVersion = "-1"
|
|
public struct ContractValidationError: Error, Equatable { public let field: String; public let code: String }
|
|
private struct AnyCodingKey: CodingKey { let stringValue: String; let intValue: Int?; init?(stringValue: String) { self.stringValue = stringValue; self.intValue = nil }; init?(intValue: Int) { self.stringValue = String(intValue); self.intValue = intValue } }
|
|
|
|
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(minimumKbps: Int64, targetKbps: Int64, maximumKbps: Int64, tier: String, audience: String, protocolValue: String, protocolVersion: Int64, grantTtlSeconds: Int64, reservationLeaseSeconds: Int64) throws {
|
|
self.minimumKbps = minimumKbps
|
|
self.targetKbps = targetKbps
|
|
self.maximumKbps = maximumKbps
|
|
self.tier = tier
|
|
self.audience = audience
|
|
self.protocolValue = protocolValue
|
|
self.protocolVersion = protocolVersion
|
|
self.grantTtlSeconds = grantTtlSeconds
|
|
self.reservationLeaseSeconds = reservationLeaseSeconds
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.minimumKbps < 1 { throw ContractValidationError(field: "minimum_kbps", code: "minimum") }
|
|
if self.minimumKbps > 100000000 { throw ContractValidationError(field: "minimum_kbps", code: "maximum") }
|
|
if self.targetKbps < 1 { throw ContractValidationError(field: "target_kbps", code: "minimum") }
|
|
if self.targetKbps > 100000000 { throw ContractValidationError(field: "target_kbps", code: "maximum") }
|
|
if self.maximumKbps < 1 { throw ContractValidationError(field: "maximum_kbps", code: "minimum") }
|
|
if self.maximumKbps > 100000000 { throw ContractValidationError(field: "maximum_kbps", code: "maximum") }
|
|
if !["standard", "priority", "premium"].contains(self.tier) { throw ContractValidationError(field: "tier", code: "invalid_value") }
|
|
if self.audience.isEmpty { throw ContractValidationError(field: "audience", code: "required") }
|
|
if !self.audience.isEmpty && self.audience.utf8.count < 1 { throw ContractValidationError(field: "audience", code: "min_length") }
|
|
if self.audience.utf8.count > 256 { throw ContractValidationError(field: "audience", code: "max_length") }
|
|
if self.protocolValue.isEmpty { throw ContractValidationError(field: "protocol", code: "required") }
|
|
if !self.protocolValue.isEmpty && self.protocolValue.utf8.count < 1 { throw ContractValidationError(field: "protocol", code: "min_length") }
|
|
if self.protocolValue.utf8.count > 64 { throw ContractValidationError(field: "protocol", code: "max_length") }
|
|
if self.protocolVersion < 1 { throw ContractValidationError(field: "protocol_version", code: "minimum") }
|
|
if self.protocolVersion > 100 { throw ContractValidationError(field: "protocol_version", code: "maximum") }
|
|
if self.grantTtlSeconds < 5 { throw ContractValidationError(field: "grant_ttl_seconds", code: "minimum") }
|
|
if self.grantTtlSeconds > 300 { throw ContractValidationError(field: "grant_ttl_seconds", code: "maximum") }
|
|
if self.reservationLeaseSeconds < 5 { throw ContractValidationError(field: "reservation_lease_seconds", code: "minimum") }
|
|
if self.reservationLeaseSeconds > 3600 { throw ContractValidationError(field: "reservation_lease_seconds", code: "maximum") }
|
|
if minimumKbps > targetKbps || targetKbps > maximumKbps { throw ContractValidationError(field: "bounds", code: "invalid_order") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(assignmentId: String, poolId: String, name: String, availability: String) throws {
|
|
self.assignmentId = assignmentId
|
|
self.poolId = poolId
|
|
self.name = name
|
|
self.availability = availability
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.assignmentId.isEmpty { throw ContractValidationError(field: "assignment_id", code: "required") }
|
|
if !self.assignmentId.isEmpty && self.assignmentId.utf8.count < 1 { throw ContractValidationError(field: "assignment_id", code: "min_length") }
|
|
if self.assignmentId.utf8.count > 128 { throw ContractValidationError(field: "assignment_id", code: "max_length") }
|
|
if self.poolId.isEmpty { throw ContractValidationError(field: "pool_id", code: "required") }
|
|
if !self.poolId.isEmpty && self.poolId.utf8.count < 1 { throw ContractValidationError(field: "pool_id", code: "min_length") }
|
|
if self.poolId.utf8.count > 128 { throw ContractValidationError(field: "pool_id", code: "max_length") }
|
|
if self.name.isEmpty { throw ContractValidationError(field: "name", code: "required") }
|
|
if !self.name.isEmpty && self.name.utf8.count < 1 { throw ContractValidationError(field: "name", code: "min_length") }
|
|
if self.name.utf8.count > 256 { throw ContractValidationError(field: "name", code: "max_length") }
|
|
if self.availability.isEmpty { throw ContractValidationError(field: "availability", code: "required") }
|
|
if !self.availability.isEmpty && self.availability.utf8.count < 1 { throw ContractValidationError(field: "availability", code: "min_length") }
|
|
if self.availability.utf8.count > 64 { throw ContractValidationError(field: "availability", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(id: String, principalId: String, poolId: String, assignmentId: String?, state: String, policySnapshot: AllocationPolicy, reconnectDeadline: String?, outcome: String?, failureCode: String?, cleanupState: String, idempotencyKey: String, correlationId: String, requestedAt: String, endedAt: String?, version: Int64) throws {
|
|
self.id = id
|
|
self.principalId = principalId
|
|
self.poolId = poolId
|
|
self.assignmentId = assignmentId
|
|
self.state = state
|
|
self.policySnapshot = policySnapshot
|
|
self.reconnectDeadline = reconnectDeadline
|
|
self.outcome = outcome
|
|
self.failureCode = failureCode
|
|
self.cleanupState = cleanupState
|
|
self.idempotencyKey = idempotencyKey
|
|
self.correlationId = correlationId
|
|
self.requestedAt = requestedAt
|
|
self.endedAt = endedAt
|
|
self.version = version
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.id.isEmpty { throw ContractValidationError(field: "id", code: "required") }
|
|
if !self.id.isEmpty && self.id.utf8.count < 1 { throw ContractValidationError(field: "id", code: "min_length") }
|
|
if self.id.utf8.count > 128 { throw ContractValidationError(field: "id", code: "max_length") }
|
|
if self.principalId.isEmpty { throw ContractValidationError(field: "principal_id", code: "required") }
|
|
if !self.principalId.isEmpty && self.principalId.utf8.count < 1 { throw ContractValidationError(field: "principal_id", code: "min_length") }
|
|
if self.principalId.utf8.count > 128 { throw ContractValidationError(field: "principal_id", code: "max_length") }
|
|
if self.poolId.isEmpty { throw ContractValidationError(field: "pool_id", code: "required") }
|
|
if !self.poolId.isEmpty && self.poolId.utf8.count < 1 { throw ContractValidationError(field: "pool_id", code: "min_length") }
|
|
if self.poolId.utf8.count > 128 { throw ContractValidationError(field: "pool_id", code: "max_length") }
|
|
if let value = self.assignmentId {
|
|
if value.utf8.count > 128 { throw ContractValidationError(field: "assignment_id", code: "max_length") }
|
|
}
|
|
if self.state.isEmpty { throw ContractValidationError(field: "state", code: "required") }
|
|
if !self.state.isEmpty && self.state.utf8.count < 1 { throw ContractValidationError(field: "state", code: "min_length") }
|
|
if self.state.utf8.count > 64 { throw ContractValidationError(field: "state", code: "max_length") }
|
|
try self.policySnapshot.validate()
|
|
if let value = self.reconnectDeadline {
|
|
if value.utf8.count > 64 { throw ContractValidationError(field: "reconnect_deadline", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: value) == nil { throw ContractValidationError(field: "reconnect_deadline", code: "invalid_time") }
|
|
}
|
|
if let value = self.outcome {
|
|
if value.utf8.count > 64 { throw ContractValidationError(field: "outcome", code: "max_length") }
|
|
}
|
|
if let value = self.failureCode {
|
|
if value.utf8.count > 128 { throw ContractValidationError(field: "failure_code", code: "max_length") }
|
|
}
|
|
if self.cleanupState.isEmpty { throw ContractValidationError(field: "cleanup_state", code: "required") }
|
|
if !self.cleanupState.isEmpty && self.cleanupState.utf8.count < 1 { throw ContractValidationError(field: "cleanup_state", code: "min_length") }
|
|
if self.cleanupState.utf8.count > 64 { throw ContractValidationError(field: "cleanup_state", code: "max_length") }
|
|
if self.idempotencyKey.isEmpty { throw ContractValidationError(field: "idempotency_key", code: "required") }
|
|
if !self.idempotencyKey.isEmpty && self.idempotencyKey.utf8.count < 1 { throw ContractValidationError(field: "idempotency_key", code: "min_length") }
|
|
if self.idempotencyKey.utf8.count > 256 { throw ContractValidationError(field: "idempotency_key", code: "max_length") }
|
|
if self.correlationId.isEmpty { throw ContractValidationError(field: "correlation_id", code: "required") }
|
|
if !self.correlationId.isEmpty && self.correlationId.utf8.count < 1 { throw ContractValidationError(field: "correlation_id", code: "min_length") }
|
|
if self.correlationId.utf8.count > 128 { throw ContractValidationError(field: "correlation_id", code: "max_length") }
|
|
if self.requestedAt.utf8.count > 64 { throw ContractValidationError(field: "requested_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.requestedAt) == nil { throw ContractValidationError(field: "requested_at", code: "invalid_time") }
|
|
if let value = self.endedAt {
|
|
if value.utf8.count > 64 { throw ContractValidationError(field: "ended_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: value) == nil { throw ContractValidationError(field: "ended_at", code: "invalid_time") }
|
|
}
|
|
if self.version < 1 { throw ContractValidationError(field: "version", code: "minimum") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(transport: String, framing: String, media: String, audio: String, sourceRateControl: String, clientDecode: String) throws {
|
|
self.transport = transport
|
|
self.framing = framing
|
|
self.media = media
|
|
self.audio = audio
|
|
self.sourceRateControl = sourceRateControl
|
|
self.clientDecode = clientDecode
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.transport.isEmpty { throw ContractValidationError(field: "transport", code: "required") }
|
|
if !self.transport.isEmpty && self.transport.utf8.count < 1 { throw ContractValidationError(field: "transport", code: "min_length") }
|
|
if self.transport.utf8.count > 64 { throw ContractValidationError(field: "transport", code: "max_length") }
|
|
if self.framing.isEmpty { throw ContractValidationError(field: "framing", code: "required") }
|
|
if !self.framing.isEmpty && self.framing.utf8.count < 1 { throw ContractValidationError(field: "framing", code: "min_length") }
|
|
if self.framing.utf8.count > 64 { throw ContractValidationError(field: "framing", code: "max_length") }
|
|
if self.media.isEmpty { throw ContractValidationError(field: "media", code: "required") }
|
|
if !self.media.isEmpty && self.media.utf8.count < 1 { throw ContractValidationError(field: "media", code: "min_length") }
|
|
if self.media.utf8.count > 64 { throw ContractValidationError(field: "media", code: "max_length") }
|
|
if self.audio.isEmpty { throw ContractValidationError(field: "audio", code: "required") }
|
|
if !self.audio.isEmpty && self.audio.utf8.count < 1 { throw ContractValidationError(field: "audio", code: "min_length") }
|
|
if self.audio.utf8.count > 64 { throw ContractValidationError(field: "audio", code: "max_length") }
|
|
if self.sourceRateControl.isEmpty { throw ContractValidationError(field: "source_rate_control", code: "required") }
|
|
if !self.sourceRateControl.isEmpty && self.sourceRateControl.utf8.count < 1 { throw ContractValidationError(field: "source_rate_control", code: "min_length") }
|
|
if self.sourceRateControl.utf8.count > 64 { throw ContractValidationError(field: "source_rate_control", code: "max_length") }
|
|
if self.clientDecode.isEmpty { throw ContractValidationError(field: "client_decode", code: "required") }
|
|
if !self.clientDecode.isEmpty && self.clientDecode.utf8.count < 1 { throw ContractValidationError(field: "client_decode", code: "min_length") }
|
|
if self.clientDecode.utf8.count > 64 { throw ContractValidationError(field: "client_decode", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, flowId: String, sequence: Int64, flags: Int64, fragmentIndex: Int64, fragmentCount: Int64, timestampMs: Int64, payload: String) throws {
|
|
self.version = version
|
|
self.flowId = flowId
|
|
self.sequence = sequence
|
|
self.flags = flags
|
|
self.fragmentIndex = fragmentIndex
|
|
self.fragmentCount = fragmentCount
|
|
self.timestampMs = timestampMs
|
|
self.payload = payload
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.flowId.isEmpty { throw ContractValidationError(field: "flow_id", code: "required") }
|
|
if !self.flowId.isEmpty && self.flowId.utf8.count < 1 { throw ContractValidationError(field: "flow_id", code: "min_length") }
|
|
if self.flowId.utf8.count > 64 { throw ContractValidationError(field: "flow_id", code: "max_length") }
|
|
if self.sequence < 0 { throw ContractValidationError(field: "sequence", code: "minimum") }
|
|
if self.flags < 0 { throw ContractValidationError(field: "flags", code: "minimum") }
|
|
if self.flags > 255 { throw ContractValidationError(field: "flags", code: "maximum") }
|
|
if self.fragmentIndex < 0 { throw ContractValidationError(field: "fragment_index", code: "minimum") }
|
|
if self.fragmentIndex > 15 { throw ContractValidationError(field: "fragment_index", code: "maximum") }
|
|
if self.fragmentCount < 1 { throw ContractValidationError(field: "fragment_count", code: "minimum") }
|
|
if self.fragmentCount > 16 { throw ContractValidationError(field: "fragment_count", code: "maximum") }
|
|
if self.timestampMs < 0 { throw ContractValidationError(field: "timestamp_ms", code: "minimum") }
|
|
if self.payload.utf8.count > 87384 { throw ContractValidationError(field: "payload", code: "max_length") }
|
|
if fragmentIndex >= fragmentCount { throw ContractValidationError(field: "fragment_index", code: "invalid_order") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(text: String, encoding: String) throws {
|
|
self.text = text
|
|
self.encoding = encoding
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(text: try c.decode(String.self, forKey: .text), encoding: try c.decode(String.self, forKey: .encoding))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.text.utf8.count > 65536 { throw ContractValidationError(field: "text", code: "max_length") }
|
|
if self.encoding != "utf-8" { throw ContractValidationError(field: "encoding", code: "invalid_value") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, purpose: String, sessionId: String, reconnectSequence: Int64, gateway: ManifestGateway, tunnel: ManifestTunnel, profile: ManifestProfile, grant: GrantReference, correlationId: String) throws {
|
|
self.version = version
|
|
self.purpose = purpose
|
|
self.sessionId = sessionId
|
|
self.reconnectSequence = reconnectSequence
|
|
self.gateway = gateway
|
|
self.tunnel = tunnel
|
|
self.profile = profile
|
|
self.grant = grant
|
|
self.correlationId = correlationId
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if !["launch", "reconnect"].contains(self.purpose) { throw ContractValidationError(field: "purpose", code: "invalid_value") }
|
|
if self.sessionId.isEmpty { throw ContractValidationError(field: "session_id", code: "required") }
|
|
if !self.sessionId.isEmpty && self.sessionId.utf8.count < 1 { throw ContractValidationError(field: "session_id", code: "min_length") }
|
|
if self.sessionId.utf8.count > 128 { throw ContractValidationError(field: "session_id", code: "max_length") }
|
|
if self.reconnectSequence < 0 { throw ContractValidationError(field: "reconnect_sequence", code: "minimum") }
|
|
try self.gateway.validate()
|
|
try self.tunnel.validate()
|
|
try self.profile.validate()
|
|
try self.grant.validate()
|
|
if self.correlationId.isEmpty { throw ContractValidationError(field: "correlation_id", code: "required") }
|
|
if !self.correlationId.isEmpty && self.correlationId.utf8.count < 1 { throw ContractValidationError(field: "correlation_id", code: "min_length") }
|
|
if self.correlationId.utf8.count > 128 { throw ContractValidationError(field: "correlation_id", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(deviceId: String, serverId: String, principalId: String, challenge: String, expiresAt: String, algorithm: String, signatureFormat: String) throws {
|
|
self.deviceId = deviceId
|
|
self.serverId = serverId
|
|
self.principalId = principalId
|
|
self.challenge = challenge
|
|
self.expiresAt = expiresAt
|
|
self.algorithm = algorithm
|
|
self.signatureFormat = signatureFormat
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.deviceId.isEmpty { throw ContractValidationError(field: "device_id", code: "required") }
|
|
if !self.deviceId.isEmpty && self.deviceId.utf8.count < 1 { throw ContractValidationError(field: "device_id", code: "min_length") }
|
|
if self.deviceId.utf8.count > 128 { throw ContractValidationError(field: "device_id", code: "max_length") }
|
|
if self.serverId.isEmpty { throw ContractValidationError(field: "server_id", code: "required") }
|
|
if !self.serverId.isEmpty && self.serverId.utf8.count < 1 { throw ContractValidationError(field: "server_id", code: "min_length") }
|
|
if self.serverId.utf8.count > 128 { throw ContractValidationError(field: "server_id", code: "max_length") }
|
|
if self.principalId.isEmpty { throw ContractValidationError(field: "principal_id", code: "required") }
|
|
if !self.principalId.isEmpty && self.principalId.utf8.count < 1 { throw ContractValidationError(field: "principal_id", code: "min_length") }
|
|
if self.principalId.utf8.count > 128 { throw ContractValidationError(field: "principal_id", code: "max_length") }
|
|
if self.challenge.isEmpty { throw ContractValidationError(field: "challenge", code: "required") }
|
|
if !self.challenge.isEmpty && self.challenge.utf8.count < 1 { throw ContractValidationError(field: "challenge", code: "min_length") }
|
|
if self.challenge.utf8.count > 256 { throw ContractValidationError(field: "challenge", code: "max_length") }
|
|
if self.expiresAt.utf8.count > 64 { throw ContractValidationError(field: "expires_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.expiresAt) == nil { throw ContractValidationError(field: "expires_at", code: "invalid_time") }
|
|
if self.algorithm != "ed25519" { throw ContractValidationError(field: "algorithm", code: "invalid_value") }
|
|
if self.signatureFormat != "ed25519-domain-separated-v1" { throw ContractValidationError(field: "signature_format", code: "invalid_value") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(challenge: String, signature: String) throws {
|
|
self.challenge = challenge
|
|
self.signature = signature
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(challenge: try c.decode(String.self, forKey: .challenge), signature: try c.decode(String.self, forKey: .signature))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.challenge.isEmpty { throw ContractValidationError(field: "challenge", code: "required") }
|
|
if !self.challenge.isEmpty && self.challenge.utf8.count < 1 { throw ContractValidationError(field: "challenge", code: "min_length") }
|
|
if self.challenge.utf8.count > 256 { throw ContractValidationError(field: "challenge", code: "max_length") }
|
|
if self.signature.isEmpty { throw ContractValidationError(field: "signature", code: "required") }
|
|
if !self.signature.isEmpty && self.signature.utf8.count < 1 { throw ContractValidationError(field: "signature", code: "min_length") }
|
|
if self.signature.utf8.count > 256 { throw ContractValidationError(field: "signature", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(name: String, platform: String, deviceSubject: String, algorithm: String, publicKey: String) throws {
|
|
self.name = name
|
|
self.platform = platform
|
|
self.deviceSubject = deviceSubject
|
|
self.algorithm = algorithm
|
|
self.publicKey = publicKey
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.name.isEmpty { throw ContractValidationError(field: "name", code: "required") }
|
|
if !self.name.isEmpty && self.name.utf8.count < 1 { throw ContractValidationError(field: "name", code: "min_length") }
|
|
if self.name.utf8.count > 128 { throw ContractValidationError(field: "name", code: "max_length") }
|
|
if self.platform.isEmpty { throw ContractValidationError(field: "platform", code: "required") }
|
|
if !self.platform.isEmpty && self.platform.utf8.count < 1 { throw ContractValidationError(field: "platform", code: "min_length") }
|
|
if self.platform.utf8.count > 64 { throw ContractValidationError(field: "platform", code: "max_length") }
|
|
if self.deviceSubject.isEmpty { throw ContractValidationError(field: "device_subject", code: "required") }
|
|
if !self.deviceSubject.isEmpty && self.deviceSubject.utf8.count < 1 { throw ContractValidationError(field: "device_subject", code: "min_length") }
|
|
if self.deviceSubject.utf8.count > 256 { throw ContractValidationError(field: "device_subject", code: "max_length") }
|
|
if self.algorithm != "ed25519" { throw ContractValidationError(field: "algorithm", code: "invalid_value") }
|
|
if self.publicKey.isEmpty { throw ContractValidationError(field: "public_key", code: "required") }
|
|
if !self.publicKey.isEmpty && self.publicKey.utf8.count < 1 { throw ContractValidationError(field: "public_key", code: "min_length") }
|
|
if self.publicKey.utf8.count > 256 { throw ContractValidationError(field: "public_key", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(poolId: String, name: String, assignmentState: String) throws {
|
|
self.poolId = poolId
|
|
self.name = name
|
|
self.assignmentState = assignmentState
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.poolId.isEmpty { throw ContractValidationError(field: "pool_id", code: "required") }
|
|
if !self.poolId.isEmpty && self.poolId.utf8.count < 1 { throw ContractValidationError(field: "pool_id", code: "min_length") }
|
|
if self.poolId.utf8.count > 128 { throw ContractValidationError(field: "pool_id", code: "max_length") }
|
|
if self.name.isEmpty { throw ContractValidationError(field: "name", code: "required") }
|
|
if !self.name.isEmpty && self.name.utf8.count < 1 { throw ContractValidationError(field: "name", code: "min_length") }
|
|
if self.name.utf8.count > 256 { throw ContractValidationError(field: "name", code: "max_length") }
|
|
if self.assignmentState.isEmpty { throw ContractValidationError(field: "assignment_state", code: "required") }
|
|
if !self.assignmentState.isEmpty && self.assignmentState.utf8.count < 1 { throw ContractValidationError(field: "assignment_state", code: "min_length") }
|
|
if self.assignmentState.utf8.count > 64 { throw ContractValidationError(field: "assignment_state", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(status: Bool, error: String, code: String, message: String, resolution: String, requestId: String, violations: [FieldViolation]) throws {
|
|
self.status = status
|
|
self.error = error
|
|
self.code = code
|
|
self.message = message
|
|
self.resolution = resolution
|
|
self.requestId = requestId
|
|
self.violations = violations
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.error.isEmpty { throw ContractValidationError(field: "error", code: "required") }
|
|
if !self.error.isEmpty && self.error.utf8.count < 1 { throw ContractValidationError(field: "error", code: "min_length") }
|
|
if self.error.utf8.count > 512 { throw ContractValidationError(field: "error", code: "max_length") }
|
|
if self.code.isEmpty { throw ContractValidationError(field: "code", code: "required") }
|
|
if !self.code.isEmpty && self.code.utf8.count < 1 { throw ContractValidationError(field: "code", code: "min_length") }
|
|
if self.code.utf8.count > 128 { throw ContractValidationError(field: "code", code: "max_length") }
|
|
if self.message.isEmpty { throw ContractValidationError(field: "message", code: "required") }
|
|
if !self.message.isEmpty && self.message.utf8.count < 1 { throw ContractValidationError(field: "message", code: "min_length") }
|
|
if self.message.utf8.count > 512 { throw ContractValidationError(field: "message", code: "max_length") }
|
|
if self.resolution.isEmpty { throw ContractValidationError(field: "resolution", code: "required") }
|
|
if !self.resolution.isEmpty && self.resolution.utf8.count < 1 { throw ContractValidationError(field: "resolution", code: "min_length") }
|
|
if self.resolution.utf8.count > 128 { throw ContractValidationError(field: "resolution", code: "max_length") }
|
|
if self.requestId.isEmpty { throw ContractValidationError(field: "request_id", code: "required") }
|
|
if !self.requestId.isEmpty && self.requestId.utf8.count < 1 { throw ContractValidationError(field: "request_id", code: "min_length") }
|
|
if self.requestId.utf8.count > 128 { throw ContractValidationError(field: "request_id", code: "max_length") }
|
|
if self.violations.count > 16 { throw ContractValidationError(field: "violations", code: "max_items") }
|
|
for item in self.violations { try item.validate() }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(eventId: String, sequence: Int64, type: String, version: Int64, resource: ResourceLink, occurredAt: String, correlationId: String, payload: JSONObject) throws {
|
|
self.eventId = eventId
|
|
self.sequence = sequence
|
|
self.type = type
|
|
self.version = version
|
|
self.resource = resource
|
|
self.occurredAt = occurredAt
|
|
self.correlationId = correlationId
|
|
self.payload = payload
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.eventId.isEmpty { throw ContractValidationError(field: "event_id", code: "required") }
|
|
if !self.eventId.isEmpty && self.eventId.utf8.count < 1 { throw ContractValidationError(field: "event_id", code: "min_length") }
|
|
if self.eventId.utf8.count > 128 { throw ContractValidationError(field: "event_id", code: "max_length") }
|
|
if self.sequence < 1 { throw ContractValidationError(field: "sequence", code: "minimum") }
|
|
if self.type.isEmpty { throw ContractValidationError(field: "type", code: "required") }
|
|
if !self.type.isEmpty && self.type.utf8.count < 1 { throw ContractValidationError(field: "type", code: "min_length") }
|
|
if self.type.utf8.count > 128 { throw ContractValidationError(field: "type", code: "max_length") }
|
|
if self.version < 1 { throw ContractValidationError(field: "version", code: "minimum") }
|
|
try self.resource.validate()
|
|
if self.occurredAt.utf8.count > 64 { throw ContractValidationError(field: "occurred_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.occurredAt) == nil { throw ContractValidationError(field: "occurred_at", code: "invalid_time") }
|
|
if self.correlationId.isEmpty { throw ContractValidationError(field: "correlation_id", code: "required") }
|
|
if !self.correlationId.isEmpty && self.correlationId.utf8.count < 1 { throw ContractValidationError(field: "correlation_id", code: "min_length") }
|
|
if self.correlationId.utf8.count > 128 { throw ContractValidationError(field: "correlation_id", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(cursor: String, lastSequence: Int64) throws {
|
|
self.cursor = cursor
|
|
self.lastSequence = lastSequence
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(cursor: try c.decode(String.self, forKey: .cursor), lastSequence: try c.decode(Int64.self, forKey: .lastSequence))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.cursor.utf8.count > 512 { throw ContractValidationError(field: "cursor", code: "max_length") }
|
|
if self.lastSequence < 0 { throw ContractValidationError(field: "last_sequence", code: "minimum") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(field: String, code: String) throws {
|
|
self.field = field
|
|
self.code = code
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(field: try c.decode(String.self, forKey: .field), code: try c.decode(String.self, forKey: .code))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.field.isEmpty { throw ContractValidationError(field: "field", code: "required") }
|
|
if !self.field.isEmpty && self.field.utf8.count < 1 { throw ContractValidationError(field: "field", code: "min_length") }
|
|
if self.field.utf8.count > 128 { throw ContractValidationError(field: "field", code: "max_length") }
|
|
if self.code.isEmpty { throw ContractValidationError(field: "code", code: "required") }
|
|
if !self.code.isEmpty && self.code.utf8.count < 1 { throw ContractValidationError(field: "code", code: "min_length") }
|
|
if self.code.utf8.count > 64 { throw ContractValidationError(field: "code", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, gatewayId: String, sequence: Int64, reason: String, deadline: String) throws {
|
|
self.version = version
|
|
self.gatewayId = gatewayId
|
|
self.sequence = sequence
|
|
self.reason = reason
|
|
self.deadline = deadline
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.gatewayId.isEmpty { throw ContractValidationError(field: "gateway_id", code: "required") }
|
|
if !self.gatewayId.isEmpty && self.gatewayId.utf8.count < 1 { throw ContractValidationError(field: "gateway_id", code: "min_length") }
|
|
if self.gatewayId.utf8.count > 128 { throw ContractValidationError(field: "gateway_id", code: "max_length") }
|
|
if self.sequence < 1 { throw ContractValidationError(field: "sequence", code: "minimum") }
|
|
if self.reason.isEmpty { throw ContractValidationError(field: "reason", code: "required") }
|
|
if !self.reason.isEmpty && self.reason.utf8.count < 1 { throw ContractValidationError(field: "reason", code: "min_length") }
|
|
if self.reason.utf8.count > 256 { throw ContractValidationError(field: "reason", code: "max_length") }
|
|
if self.deadline.utf8.count > 64 { throw ContractValidationError(field: "deadline", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.deadline) == nil { throw ContractValidationError(field: "deadline", code: "invalid_time") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, gatewayId: String, sequence: Int64, observedAt: String, activeConnections: Int64, egressKbps: Int64, state: String) throws {
|
|
self.version = version
|
|
self.gatewayId = gatewayId
|
|
self.sequence = sequence
|
|
self.observedAt = observedAt
|
|
self.activeConnections = activeConnections
|
|
self.egressKbps = egressKbps
|
|
self.state = state
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.gatewayId.isEmpty { throw ContractValidationError(field: "gateway_id", code: "required") }
|
|
if !self.gatewayId.isEmpty && self.gatewayId.utf8.count < 1 { throw ContractValidationError(field: "gateway_id", code: "min_length") }
|
|
if self.gatewayId.utf8.count > 128 { throw ContractValidationError(field: "gateway_id", code: "max_length") }
|
|
if self.sequence < 1 { throw ContractValidationError(field: "sequence", code: "minimum") }
|
|
if self.observedAt.utf8.count > 64 { throw ContractValidationError(field: "observed_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.observedAt) == nil { throw ContractValidationError(field: "observed_at", code: "invalid_time") }
|
|
if self.activeConnections < 0 { throw ContractValidationError(field: "active_connections", code: "minimum") }
|
|
if self.activeConnections > 1000000 { throw ContractValidationError(field: "active_connections", code: "maximum") }
|
|
if self.egressKbps < 0 { throw ContractValidationError(field: "egress_kbps", code: "minimum") }
|
|
if self.egressKbps > 1000000000 { throw ContractValidationError(field: "egress_kbps", code: "maximum") }
|
|
if !["ready", "draining", "offline"].contains(self.state) { throw ContractValidationError(field: "state", code: "invalid_value") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, gatewayId: String, instanceIdentity: String, certificateIdentity: String, publicIdentity: String, address: String, providerIdentity: String, protocolMinVersion: Int64, protocolMaxVersion: Int64, connectionCapacity: Int64, bandwidthCapacityKbps: Int64, features: [String], capabilities: CapabilityProfile) throws {
|
|
self.version = version
|
|
self.gatewayId = gatewayId
|
|
self.instanceIdentity = instanceIdentity
|
|
self.certificateIdentity = certificateIdentity
|
|
self.publicIdentity = publicIdentity
|
|
self.address = address
|
|
self.providerIdentity = providerIdentity
|
|
self.protocolMinVersion = protocolMinVersion
|
|
self.protocolMaxVersion = protocolMaxVersion
|
|
self.connectionCapacity = connectionCapacity
|
|
self.bandwidthCapacityKbps = bandwidthCapacityKbps
|
|
self.features = features
|
|
self.capabilities = capabilities
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.gatewayId.isEmpty { throw ContractValidationError(field: "gateway_id", code: "required") }
|
|
if !self.gatewayId.isEmpty && self.gatewayId.utf8.count < 1 { throw ContractValidationError(field: "gateway_id", code: "min_length") }
|
|
if self.gatewayId.utf8.count > 128 { throw ContractValidationError(field: "gateway_id", code: "max_length") }
|
|
if self.instanceIdentity.isEmpty { throw ContractValidationError(field: "instance_identity", code: "required") }
|
|
if !self.instanceIdentity.isEmpty && self.instanceIdentity.utf8.count < 1 { throw ContractValidationError(field: "instance_identity", code: "min_length") }
|
|
if self.instanceIdentity.utf8.count > 512 { throw ContractValidationError(field: "instance_identity", code: "max_length") }
|
|
if self.certificateIdentity.isEmpty { throw ContractValidationError(field: "certificate_identity", code: "required") }
|
|
if !self.certificateIdentity.isEmpty && self.certificateIdentity.utf8.count < 1 { throw ContractValidationError(field: "certificate_identity", code: "min_length") }
|
|
if self.certificateIdentity.utf8.count > 512 { throw ContractValidationError(field: "certificate_identity", code: "max_length") }
|
|
if self.publicIdentity.isEmpty { throw ContractValidationError(field: "public_identity", code: "required") }
|
|
if !self.publicIdentity.isEmpty && self.publicIdentity.utf8.count < 1 { throw ContractValidationError(field: "public_identity", code: "min_length") }
|
|
if self.publicIdentity.utf8.count > 256 { throw ContractValidationError(field: "public_identity", code: "max_length") }
|
|
if self.address.isEmpty { throw ContractValidationError(field: "address", code: "required") }
|
|
if !self.address.isEmpty && self.address.utf8.count < 1 { throw ContractValidationError(field: "address", code: "min_length") }
|
|
if self.address.utf8.count > 256 { throw ContractValidationError(field: "address", code: "max_length") }
|
|
if self.providerIdentity.isEmpty { throw ContractValidationError(field: "provider_identity", code: "required") }
|
|
if !self.providerIdentity.isEmpty && self.providerIdentity.utf8.count < 1 { throw ContractValidationError(field: "provider_identity", code: "min_length") }
|
|
if self.providerIdentity.utf8.count > 256 { throw ContractValidationError(field: "provider_identity", code: "max_length") }
|
|
if self.protocolMinVersion < 1 { throw ContractValidationError(field: "protocol_min_version", code: "minimum") }
|
|
if self.protocolMinVersion > 100 { throw ContractValidationError(field: "protocol_min_version", code: "maximum") }
|
|
if self.protocolMaxVersion < 1 { throw ContractValidationError(field: "protocol_max_version", code: "minimum") }
|
|
if self.protocolMaxVersion > 100 { throw ContractValidationError(field: "protocol_max_version", code: "maximum") }
|
|
if self.connectionCapacity < 1 { throw ContractValidationError(field: "connection_capacity", code: "minimum") }
|
|
if self.connectionCapacity > 1000000 { throw ContractValidationError(field: "connection_capacity", code: "maximum") }
|
|
if self.bandwidthCapacityKbps < 1 { throw ContractValidationError(field: "bandwidth_capacity_kbps", code: "minimum") }
|
|
if self.bandwidthCapacityKbps > 1000000000 { throw ContractValidationError(field: "bandwidth_capacity_kbps", code: "maximum") }
|
|
if self.features.count > 64 { throw ContractValidationError(field: "features", code: "max_items") }
|
|
try self.capabilities.validate()
|
|
if protocolMinVersion > protocolMaxVersion { throw ContractValidationError(field: "protocol_version", code: "invalid_order") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(opaqueValue: String, expiresAt: String, audience: String) throws {
|
|
self.opaqueValue = opaqueValue
|
|
self.expiresAt = expiresAt
|
|
self.audience = audience
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.opaqueValue.isEmpty { throw ContractValidationError(field: "opaque_value", code: "required") }
|
|
if !self.opaqueValue.isEmpty && self.opaqueValue.utf8.count < 43 { throw ContractValidationError(field: "opaque_value", code: "min_length") }
|
|
if self.opaqueValue.utf8.count > 256 { throw ContractValidationError(field: "opaque_value", code: "max_length") }
|
|
if self.expiresAt.utf8.count > 64 { throw ContractValidationError(field: "expires_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.expiresAt) == nil { throw ContractValidationError(field: "expires_at", code: "invalid_time") }
|
|
if self.audience.isEmpty { throw ContractValidationError(field: "audience", code: "required") }
|
|
if !self.audience.isEmpty && self.audience.utf8.count < 1 { throw ContractValidationError(field: "audience", code: "min_length") }
|
|
if self.audience.utf8.count > 128 { throw ContractValidationError(field: "audience", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(provider: String?, username: String, password: String) throws {
|
|
self.provider = provider
|
|
self.username = username
|
|
self.password = password
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if let value = self.provider {
|
|
if !["ldap", "local"].contains(value) { throw ContractValidationError(field: "provider", code: "invalid_value") }
|
|
}
|
|
if self.username.isEmpty { throw ContractValidationError(field: "username", code: "required") }
|
|
if !self.username.isEmpty && self.username.utf8.count < 1 { throw ContractValidationError(field: "username", code: "min_length") }
|
|
if self.username.utf8.count > 256 { throw ContractValidationError(field: "username", code: "max_length") }
|
|
if self.password.isEmpty { throw ContractValidationError(field: "password", code: "required") }
|
|
if !self.password.isEmpty && self.password.utf8.count < 1 { throw ContractValidationError(field: "password", code: "min_length") }
|
|
if self.password.utf8.count > 1024 { throw ContractValidationError(field: "password", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(minimumKbps: Int64, targetKbps: Int64, maximumKbps: Int64) throws {
|
|
self.minimumKbps = minimumKbps
|
|
self.targetKbps = targetKbps
|
|
self.maximumKbps = maximumKbps
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.minimumKbps < 1 { throw ContractValidationError(field: "minimum_kbps", code: "minimum") }
|
|
if self.minimumKbps > 100000000 { throw ContractValidationError(field: "minimum_kbps", code: "maximum") }
|
|
if self.targetKbps < 1 { throw ContractValidationError(field: "target_kbps", code: "minimum") }
|
|
if self.targetKbps > 100000000 { throw ContractValidationError(field: "target_kbps", code: "maximum") }
|
|
if self.maximumKbps < 1 { throw ContractValidationError(field: "maximum_kbps", code: "minimum") }
|
|
if self.maximumKbps > 100000000 { throw ContractValidationError(field: "maximum_kbps", code: "maximum") }
|
|
if minimumKbps > targetKbps || targetKbps > maximumKbps { throw ContractValidationError(field: "bounds", code: "invalid_order") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(id: String, addresses: [String], publicIdentity: String) throws {
|
|
self.id = id
|
|
self.addresses = addresses
|
|
self.publicIdentity = publicIdentity
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.id.isEmpty { throw ContractValidationError(field: "id", code: "required") }
|
|
if !self.id.isEmpty && self.id.utf8.count < 1 { throw ContractValidationError(field: "id", code: "min_length") }
|
|
if self.id.utf8.count > 128 { throw ContractValidationError(field: "id", code: "max_length") }
|
|
if self.addresses.count < 1 { throw ContractValidationError(field: "addresses", code: "min_items") }
|
|
if self.addresses.count > 4 { throw ContractValidationError(field: "addresses", code: "max_items") }
|
|
if self.publicIdentity.isEmpty { throw ContractValidationError(field: "public_identity", code: "required") }
|
|
if !self.publicIdentity.isEmpty && self.publicIdentity.utf8.count < 1 { throw ContractValidationError(field: "public_identity", code: "min_length") }
|
|
if self.publicIdentity.utf8.count > 256 { throw ContractValidationError(field: "public_identity", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(id: String, bounds: ManifestBounds) throws {
|
|
self.id = id
|
|
self.bounds = bounds
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(id: try c.decode(String.self, forKey: .id), bounds: try c.decode(ManifestBounds.self, forKey: .bounds))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.id.isEmpty { throw ContractValidationError(field: "id", code: "required") }
|
|
if !self.id.isEmpty && self.id.utf8.count < 1 { throw ContractValidationError(field: "id", code: "min_length") }
|
|
if self.id.utf8.count > 128 { throw ContractValidationError(field: "id", code: "max_length") }
|
|
try self.bounds.validate()
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(versions: [String], features: [String]) throws {
|
|
self.versions = versions
|
|
self.features = features
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(versions: try c.decode([String].self, forKey: .versions), features: try c.decode([String].self, forKey: .features))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.versions.count < 1 { throw ContractValidationError(field: "versions", code: "min_items") }
|
|
if self.versions.count > 4 { throw ContractValidationError(field: "versions", code: "max_items") }
|
|
if self.features.count > 32 { throw ContractValidationError(field: "features", code: "max_items") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(deviceId: String?, familyId: String, accessToken: String, refreshToken: String, expiresAt: String, refreshExpiresAt: String?) throws {
|
|
self.deviceId = deviceId
|
|
self.familyId = familyId
|
|
self.accessToken = accessToken
|
|
self.refreshToken = refreshToken
|
|
self.expiresAt = expiresAt
|
|
self.refreshExpiresAt = refreshExpiresAt
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if let value = self.deviceId {
|
|
if value.utf8.count > 128 { throw ContractValidationError(field: "device_id", code: "max_length") }
|
|
}
|
|
if self.familyId.isEmpty { throw ContractValidationError(field: "family_id", code: "required") }
|
|
if !self.familyId.isEmpty && self.familyId.utf8.count < 1 { throw ContractValidationError(field: "family_id", code: "min_length") }
|
|
if self.familyId.utf8.count > 128 { throw ContractValidationError(field: "family_id", code: "max_length") }
|
|
if self.accessToken.isEmpty { throw ContractValidationError(field: "access_token", code: "required") }
|
|
if !self.accessToken.isEmpty && self.accessToken.utf8.count < 1 { throw ContractValidationError(field: "access_token", code: "min_length") }
|
|
if self.accessToken.utf8.count > 256 { throw ContractValidationError(field: "access_token", code: "max_length") }
|
|
if self.refreshToken.isEmpty { throw ContractValidationError(field: "refresh_token", code: "required") }
|
|
if !self.refreshToken.isEmpty && self.refreshToken.utf8.count < 1 { throw ContractValidationError(field: "refresh_token", code: "min_length") }
|
|
if self.refreshToken.utf8.count > 256 { throw ContractValidationError(field: "refresh_token", code: "max_length") }
|
|
if self.expiresAt.utf8.count > 64 { throw ContractValidationError(field: "expires_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.expiresAt) == nil { throw ContractValidationError(field: "expires_at", code: "invalid_time") }
|
|
if let value = self.refreshExpiresAt {
|
|
if value.utf8.count > 64 { throw ContractValidationError(field: "refresh_expires_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: value) == nil { throw ContractValidationError(field: "refresh_expires_at", code: "invalid_time") }
|
|
}
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(limit: Int64, nextCursor: String) throws {
|
|
self.limit = limit
|
|
self.nextCursor = nextCursor
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(limit: try c.decode(Int64.self, forKey: .limit), nextCursor: try c.decode(String.self, forKey: .nextCursor))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.limit < 1 { throw ContractValidationError(field: "limit", code: "minimum") }
|
|
if self.limit > 100 { throw ContractValidationError(field: "limit", code: "maximum") }
|
|
if self.nextCursor.utf8.count > 512 { throw ContractValidationError(field: "next_cursor", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, sessionId: String, state: String, cleanupPending: Bool, channels: [String]) throws {
|
|
self.version = version
|
|
self.sessionId = sessionId
|
|
self.state = state
|
|
self.cleanupPending = cleanupPending
|
|
self.channels = channels
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.sessionId.isEmpty { throw ContractValidationError(field: "session_id", code: "required") }
|
|
if !self.sessionId.isEmpty && self.sessionId.utf8.count < 1 { throw ContractValidationError(field: "session_id", code: "min_length") }
|
|
if self.sessionId.utf8.count > 128 { throw ContractValidationError(field: "session_id", code: "max_length") }
|
|
if !["starting", "ready", "disconnected", "terminating", "terminated", "cleanup_pending", "failed"].contains(self.state) { throw ContractValidationError(field: "state", code: "invalid_value") }
|
|
if self.channels.count > 8 { throw ContractValidationError(field: "channels", code: "max_items") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(token: String, purpose: String, expiresAt: String) throws {
|
|
self.token = token
|
|
self.purpose = purpose
|
|
self.expiresAt = expiresAt
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.token.isEmpty { throw ContractValidationError(field: "token", code: "required") }
|
|
if !self.token.isEmpty && self.token.utf8.count < 1 { throw ContractValidationError(field: "token", code: "min_length") }
|
|
if self.token.utf8.count > 256 { throw ContractValidationError(field: "token", code: "max_length") }
|
|
if self.purpose.isEmpty { throw ContractValidationError(field: "purpose", code: "required") }
|
|
if !self.purpose.isEmpty && self.purpose.utf8.count < 1 { throw ContractValidationError(field: "purpose", code: "min_length") }
|
|
if self.purpose.utf8.count > 64 { throw ContractValidationError(field: "purpose", code: "max_length") }
|
|
if self.expiresAt.utf8.count > 64 { throw ContractValidationError(field: "expires_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.expiresAt) == nil { throw ContractValidationError(field: "expires_at", code: "invalid_time") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(password: String, purpose: String) throws {
|
|
self.password = password
|
|
self.purpose = purpose
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(password: try c.decode(String.self, forKey: .password), purpose: try c.decode(String.self, forKey: .purpose))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.password.isEmpty { throw ContractValidationError(field: "password", code: "required") }
|
|
if !self.password.isEmpty && self.password.utf8.count < 1 { throw ContractValidationError(field: "password", code: "min_length") }
|
|
if self.password.utf8.count > 1024 { throw ContractValidationError(field: "password", code: "max_length") }
|
|
if !["identity_change", "key_change", "backup_enable", "external_database_tls_disabled", "assignment_change"].contains(self.purpose) { throw ContractValidationError(field: "purpose", code: "invalid_value") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(clientDeviceId: String, deviceKeyId: String, expectedVersion: Int64) throws {
|
|
self.clientDeviceId = clientDeviceId
|
|
self.deviceKeyId = deviceKeyId
|
|
self.expectedVersion = expectedVersion
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.clientDeviceId.isEmpty { throw ContractValidationError(field: "client_device_id", code: "required") }
|
|
if !self.clientDeviceId.isEmpty && self.clientDeviceId.utf8.count < 1 { throw ContractValidationError(field: "client_device_id", code: "min_length") }
|
|
if self.clientDeviceId.utf8.count > 128 { throw ContractValidationError(field: "client_device_id", code: "max_length") }
|
|
if self.deviceKeyId.isEmpty { throw ContractValidationError(field: "device_key_id", code: "required") }
|
|
if !self.deviceKeyId.isEmpty && self.deviceKeyId.utf8.count < 1 { throw ContractValidationError(field: "device_key_id", code: "min_length") }
|
|
if self.deviceKeyId.utf8.count > 128 { throw ContractValidationError(field: "device_key_id", code: "max_length") }
|
|
if self.expectedVersion < 1 { throw ContractValidationError(field: "expected_version", code: "minimum") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(familyId: String, refreshToken: String) throws {
|
|
self.familyId = familyId
|
|
self.refreshToken = refreshToken
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(familyId: try c.decode(String.self, forKey: .familyId), refreshToken: try c.decode(String.self, forKey: .refreshToken))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.familyId.isEmpty { throw ContractValidationError(field: "family_id", code: "required") }
|
|
if !self.familyId.isEmpty && self.familyId.utf8.count < 1 { throw ContractValidationError(field: "family_id", code: "min_length") }
|
|
if self.familyId.utf8.count > 128 { throw ContractValidationError(field: "family_id", code: "max_length") }
|
|
if self.refreshToken.isEmpty { throw ContractValidationError(field: "refresh_token", code: "required") }
|
|
if !self.refreshToken.isEmpty && self.refreshToken.utf8.count < 1 { throw ContractValidationError(field: "refresh_token", code: "min_length") }
|
|
if self.refreshToken.utf8.count > 256 { throw ContractValidationError(field: "refresh_token", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(id: String, kind: String, name: String, state: String, assignmentState: String?, version: Int64, links: [ResourceLink]) throws {
|
|
self.id = id
|
|
self.kind = kind
|
|
self.name = name
|
|
self.state = state
|
|
self.assignmentState = assignmentState
|
|
self.version = version
|
|
self.links = links
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.id.isEmpty { throw ContractValidationError(field: "id", code: "required") }
|
|
if !self.id.isEmpty && self.id.utf8.count < 1 { throw ContractValidationError(field: "id", code: "min_length") }
|
|
if self.id.utf8.count > 128 { throw ContractValidationError(field: "id", code: "max_length") }
|
|
if self.kind.isEmpty { throw ContractValidationError(field: "kind", code: "required") }
|
|
if !self.kind.isEmpty && self.kind.utf8.count < 1 { throw ContractValidationError(field: "kind", code: "min_length") }
|
|
if self.kind.utf8.count > 64 { throw ContractValidationError(field: "kind", code: "max_length") }
|
|
if self.name.isEmpty { throw ContractValidationError(field: "name", code: "required") }
|
|
if !self.name.isEmpty && self.name.utf8.count < 1 { throw ContractValidationError(field: "name", code: "min_length") }
|
|
if self.name.utf8.count > 256 { throw ContractValidationError(field: "name", code: "max_length") }
|
|
if self.state.isEmpty { throw ContractValidationError(field: "state", code: "required") }
|
|
if !self.state.isEmpty && self.state.utf8.count < 1 { throw ContractValidationError(field: "state", code: "min_length") }
|
|
if self.state.utf8.count > 64 { throw ContractValidationError(field: "state", code: "max_length") }
|
|
if let value = self.assignmentState {
|
|
if value.utf8.count > 64 { throw ContractValidationError(field: "assignment_state", code: "max_length") }
|
|
}
|
|
if self.version < 1 { throw ContractValidationError(field: "version", code: "minimum") }
|
|
if self.links.count > 16 { throw ContractValidationError(field: "links", code: "max_items") }
|
|
for item in self.links { try item.validate() }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(type: String, id: String, version: Int64) throws {
|
|
self.type = type
|
|
self.id = id
|
|
self.version = version
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.type.isEmpty { throw ContractValidationError(field: "type", code: "required") }
|
|
if !self.type.isEmpty && self.type.utf8.count < 1 { throw ContractValidationError(field: "type", code: "min_length") }
|
|
if self.type.utf8.count > 64 { throw ContractValidationError(field: "type", code: "max_length") }
|
|
if self.id.isEmpty { throw ContractValidationError(field: "id", code: "required") }
|
|
if !self.id.isEmpty && self.id.utf8.count < 1 { throw ContractValidationError(field: "id", code: "min_length") }
|
|
if self.id.utf8.count > 128 { throw ContractValidationError(field: "id", code: "max_length") }
|
|
if self.version < 1 { throw ContractValidationError(field: "version", code: "minimum") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(assignedDesktops: [AssignedDesktop], entitledPools: [EntitledPool], page: PageInfo) throws {
|
|
self.assignedDesktops = assignedDesktops
|
|
self.entitledPools = entitledPools
|
|
self.page = page
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.assignedDesktops.count > 100 { throw ContractValidationError(field: "assigned_desktops", code: "max_items") }
|
|
for item in self.assignedDesktops { try item.validate() }
|
|
if self.entitledPools.count > 100 { throw ContractValidationError(field: "entitled_pools", code: "max_items") }
|
|
for item in self.entitledPools { try item.validate() }
|
|
try self.page.validate()
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, sessionId: String, gatewayId: String, audience: String, reconnectSequence: Int64, expiresAt: String, capabilities: CapabilityProfile, providerProfile: String, providerIdentity: String) throws {
|
|
self.version = version
|
|
self.sessionId = sessionId
|
|
self.gatewayId = gatewayId
|
|
self.audience = audience
|
|
self.reconnectSequence = reconnectSequence
|
|
self.expiresAt = expiresAt
|
|
self.capabilities = capabilities
|
|
self.providerProfile = providerProfile
|
|
self.providerIdentity = providerIdentity
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.sessionId.isEmpty { throw ContractValidationError(field: "session_id", code: "required") }
|
|
if !self.sessionId.isEmpty && self.sessionId.utf8.count < 1 { throw ContractValidationError(field: "session_id", code: "min_length") }
|
|
if self.sessionId.utf8.count > 128 { throw ContractValidationError(field: "session_id", code: "max_length") }
|
|
if self.gatewayId.isEmpty { throw ContractValidationError(field: "gateway_id", code: "required") }
|
|
if !self.gatewayId.isEmpty && self.gatewayId.utf8.count < 1 { throw ContractValidationError(field: "gateway_id", code: "min_length") }
|
|
if self.gatewayId.utf8.count > 128 { throw ContractValidationError(field: "gateway_id", code: "max_length") }
|
|
if self.audience.isEmpty { throw ContractValidationError(field: "audience", code: "required") }
|
|
if !self.audience.isEmpty && self.audience.utf8.count < 1 { throw ContractValidationError(field: "audience", code: "min_length") }
|
|
if self.audience.utf8.count > 256 { throw ContractValidationError(field: "audience", code: "max_length") }
|
|
if self.reconnectSequence < 0 { throw ContractValidationError(field: "reconnect_sequence", code: "minimum") }
|
|
if self.expiresAt.utf8.count > 64 { throw ContractValidationError(field: "expires_at", code: "max_length") }
|
|
if ISO8601DateFormatter().date(from: self.expiresAt) == nil { throw ContractValidationError(field: "expires_at", code: "invalid_time") }
|
|
try self.capabilities.validate()
|
|
if !["apollo"].contains(self.providerProfile) { throw ContractValidationError(field: "provider_profile", code: "invalid_value") }
|
|
if self.providerIdentity.isEmpty { throw ContractValidationError(field: "provider_identity", code: "required") }
|
|
if !self.providerIdentity.isEmpty && self.providerIdentity.utf8.count < 1 { throw ContractValidationError(field: "provider_identity", code: "min_length") }
|
|
if self.providerIdentity.utf8.count > 256 { throw ContractValidationError(field: "provider_identity", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(clientDeviceId: String, deviceKeyId: String, poolId: String, idempotencyKey: String, policySnapshot: AllocationPolicy) throws {
|
|
self.clientDeviceId = clientDeviceId
|
|
self.deviceKeyId = deviceKeyId
|
|
self.poolId = poolId
|
|
self.idempotencyKey = idempotencyKey
|
|
self.policySnapshot = policySnapshot
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.clientDeviceId.isEmpty { throw ContractValidationError(field: "client_device_id", code: "required") }
|
|
if !self.clientDeviceId.isEmpty && self.clientDeviceId.utf8.count < 1 { throw ContractValidationError(field: "client_device_id", code: "min_length") }
|
|
if self.clientDeviceId.utf8.count > 128 { throw ContractValidationError(field: "client_device_id", code: "max_length") }
|
|
if self.deviceKeyId.isEmpty { throw ContractValidationError(field: "device_key_id", code: "required") }
|
|
if !self.deviceKeyId.isEmpty && self.deviceKeyId.utf8.count < 1 { throw ContractValidationError(field: "device_key_id", code: "min_length") }
|
|
if self.deviceKeyId.utf8.count > 128 { throw ContractValidationError(field: "device_key_id", code: "max_length") }
|
|
if self.poolId.isEmpty { throw ContractValidationError(field: "pool_id", code: "required") }
|
|
if !self.poolId.isEmpty && self.poolId.utf8.count < 1 { throw ContractValidationError(field: "pool_id", code: "min_length") }
|
|
if self.poolId.utf8.count > 128 { throw ContractValidationError(field: "pool_id", code: "max_length") }
|
|
if self.idempotencyKey.isEmpty { throw ContractValidationError(field: "idempotency_key", code: "required") }
|
|
if !self.idempotencyKey.isEmpty && self.idempotencyKey.utf8.count < 1 { throw ContractValidationError(field: "idempotency_key", code: "min_length") }
|
|
if self.idempotencyKey.utf8.count > 256 { throw ContractValidationError(field: "idempotency_key", code: "max_length") }
|
|
try self.policySnapshot.validate()
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(version: String, code: String, message: String, retryable: Bool) throws {
|
|
self.version = version
|
|
self.code = code
|
|
self.message = message
|
|
self.retryable = retryable
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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 func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.code.isEmpty { throw ContractValidationError(field: "code", code: "required") }
|
|
if !self.code.isEmpty && self.code.utf8.count < 1 { throw ContractValidationError(field: "code", code: "min_length") }
|
|
if self.code.utf8.count > 128 { throw ContractValidationError(field: "code", code: "max_length") }
|
|
if self.message.isEmpty { throw ContractValidationError(field: "message", code: "required") }
|
|
if !self.message.isEmpty && self.message.utf8.count < 1 { throw ContractValidationError(field: "message", code: "min_length") }
|
|
if self.message.utf8.count > 512 { throw ContractValidationError(field: "message", code: "max_length") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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 deviceSignature: 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 deviceSignature = "device_signature"
|
|
case capabilities = "capabilities"
|
|
}
|
|
|
|
public init(version: String, sessionId: String, gatewayId: String, audience: String, grant: String, reconnectSequence: Int64, clientNonce: String, deviceSignature: String, capabilities: CapabilityProfile) throws {
|
|
self.version = version
|
|
self.sessionId = sessionId
|
|
self.gatewayId = gatewayId
|
|
self.audience = audience
|
|
self.grant = grant
|
|
self.reconnectSequence = reconnectSequence
|
|
self.clientNonce = clientNonce
|
|
self.deviceSignature = deviceSignature
|
|
self.capabilities = capabilities
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(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), deviceSignature: try c.decode(String.self, forKey: .deviceSignature), capabilities: try c.decode(CapabilityProfile.self, forKey: .capabilities))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.version != "1" { throw ContractValidationError(field: "version", code: "invalid_value") }
|
|
if self.sessionId.isEmpty { throw ContractValidationError(field: "session_id", code: "required") }
|
|
if !self.sessionId.isEmpty && self.sessionId.utf8.count < 1 { throw ContractValidationError(field: "session_id", code: "min_length") }
|
|
if self.sessionId.utf8.count > 128 { throw ContractValidationError(field: "session_id", code: "max_length") }
|
|
if self.gatewayId.isEmpty { throw ContractValidationError(field: "gateway_id", code: "required") }
|
|
if !self.gatewayId.isEmpty && self.gatewayId.utf8.count < 1 { throw ContractValidationError(field: "gateway_id", code: "min_length") }
|
|
if self.gatewayId.utf8.count > 128 { throw ContractValidationError(field: "gateway_id", code: "max_length") }
|
|
if self.audience.isEmpty { throw ContractValidationError(field: "audience", code: "required") }
|
|
if !self.audience.isEmpty && self.audience.utf8.count < 1 { throw ContractValidationError(field: "audience", code: "min_length") }
|
|
if self.audience.utf8.count > 256 { throw ContractValidationError(field: "audience", code: "max_length") }
|
|
if self.grant.isEmpty { throw ContractValidationError(field: "grant", code: "required") }
|
|
if !self.grant.isEmpty && self.grant.utf8.count < 43 { throw ContractValidationError(field: "grant", code: "min_length") }
|
|
if self.grant.utf8.count > 256 { throw ContractValidationError(field: "grant", code: "max_length") }
|
|
if self.reconnectSequence < 0 { throw ContractValidationError(field: "reconnect_sequence", code: "minimum") }
|
|
if self.clientNonce.isEmpty { throw ContractValidationError(field: "client_nonce", code: "required") }
|
|
if !self.clientNonce.isEmpty && self.clientNonce.utf8.count < 16 { throw ContractValidationError(field: "client_nonce", code: "min_length") }
|
|
if self.clientNonce.utf8.count > 128 { throw ContractValidationError(field: "client_nonce", code: "max_length") }
|
|
if self.deviceSignature.isEmpty { throw ContractValidationError(field: "device_signature", code: "required") }
|
|
if !self.deviceSignature.isEmpty && self.deviceSignature.utf8.count < 86 { throw ContractValidationError(field: "device_signature", code: "min_length") }
|
|
if self.deviceSignature.utf8.count > 86 { throw ContractValidationError(field: "device_signature", code: "max_length") }
|
|
try self.capabilities.validate()
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
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(supportedVersions: [String], features: [String]) throws {
|
|
self.supportedVersions = supportedVersions
|
|
self.features = features
|
|
try validate()
|
|
}
|
|
|
|
public init(from decoder: Decoder) throws {
|
|
let all = try decoder.container(keyedBy: AnyCodingKey.self)
|
|
for key in all.allKeys where CodingKeys(stringValue: key.stringValue) == nil { throw ContractValidationError(field: key.stringValue, code: "unknown_field") }
|
|
let c = try decoder.container(keyedBy: CodingKeys.self)
|
|
try self.init(supportedVersions: try c.decode([String].self, forKey: .supportedVersions), features: try c.decode([String].self, forKey: .features))
|
|
}
|
|
|
|
public func validate() throws {
|
|
if self.supportedVersions.count < 1 { throw ContractValidationError(field: "supported_versions", code: "min_items") }
|
|
if self.supportedVersions.count > 3 { throw ContractValidationError(field: "supported_versions", code: "max_items") }
|
|
if self.features.count > 64 { throw ContractValidationError(field: "features", code: "max_items") }
|
|
}
|
|
|
|
public static func decodeJSON(_ data: Data) throws -> Self { try JSONDecoder().decode(Self.self, from: data) }
|
|
public func encodeJSON() throws -> Data { try validate(); return try JSONEncoder().encode(self) }
|
|
}
|
|
|
|
public extension TunnelAdmissionRequest {
|
|
func deviceAdmissionTranscript() -> Data {
|
|
let fields = [sessionId, gatewayId, audience, grant, String(reconnectSequence), clientNonce, capabilities.transport, capabilities.framing, capabilities.media, capabilities.audio, capabilities.sourceRateControl, capabilities.clientDecode]
|
|
var transcript = "versevdi/tunnel-admission/v1"
|
|
for field in fields { transcript += "\(field.utf8.count):\(field)" }
|
|
return Data(transcript.utf8)
|
|
}
|
|
}
|
|
|
|
public extension CapabilityProfile {
|
|
static func intersection(_ profiles: [CapabilityProfile]) throws -> CapabilityProfile {
|
|
guard let selected = profiles.first else { throw ContractValidationError(field: "capabilities", code: "no_overlap") }
|
|
try selected.validate()
|
|
for profile in profiles.dropFirst() {
|
|
try profile.validate()
|
|
if profile != selected { throw ContractValidationError(field: "capabilities", code: "no_overlap") }
|
|
}
|
|
return selected
|
|
}
|
|
}
|