swift-sdk/Sources/Hanzo/Models/RiskLineage.swift

//
// RiskLineage.swift
//
// Generated by openapi-generator
// https://openapi-generator.tech
//

import Foundation

public struct RiskLineage: Sendable, Codable, ParameterConvertible, Hashable {

    /** Dataset is the dataset traced. */
    public var dataset: String?
    /** Digest is the version's fingerprint, repeated here so a lineage answer is self-contained. */
    public var digest: String?
    /** From is where the window actually read opens, RFC 3339. Same as the spec's. */
    public var from: String?
    /** Holds is what the source holds for the same window NOW. The difference between it and Rows is the whole of the reproducibility claim. */
    public var holds: Int64?
    /** Oversize is how many subjects the window held that were too large to represent when this version was built. It is part of the fingerprint, so it is part of what \"reproducible\" is measured over. */
    public var oversize: Int64?
    /** Refusal says which way it failed — the window expired, or the source now holds a different count. Absent when Reproducible is true. */
    public var refusal: String?
    /** Reproducible is true when the source still holds what this version was built from — measured by asking it again, not recalled. False is ordinary: the source is fed by a rollup that runs behind the events, so \"it holds more now\" is the common case and it means re-running the spec would not produce this version. */
    public var reproducible: Bool?
    /** Retention is the source's own expiry rule as the store reports it, read at materialisation time rather than assumed. A source whose retention is shorter than this window cannot re-derive it. */
    public var retention: String?
    /** Rows is how many rows the source held for that window at materialisation time. Holds is the same question asked now, and the difference between them is the whole of the reproducibility claim. */
    public var rows: Int64?
    /** Share is the fraction of subjects admitted, in thousandths. */
    public var share: Int64?
    /** Source is the plane the rows were derived from. */
    public var source: String?
    /** Subjects is how many distinct subjects those rows belonged to. It is the real sample size — the row count flatters it whenever a subject is active. */
    public var subjects: Int64?
    /** To is where it ends: the spec's own end pulled BACK by the maturity horizon, so it is usually earlier than the spec says. This is the window a reproduction has to ask for — asking the spec's would not return these rows. */
    public var to: String?
    /** Version is the version traced — the one asked for, or the newest published one when the request named none. */
    public var version: Int64?

    public init(dataset: String? = nil, digest: String? = nil, from: String? = nil, holds: Int64? = nil, oversize: Int64? = nil, refusal: String? = nil, reproducible: Bool? = nil, retention: String? = nil, rows: Int64? = nil, share: Int64? = nil, source: String? = nil, subjects: Int64? = nil, to: String? = nil, version: Int64? = nil) {
        self.dataset = dataset
        self.digest = digest
        self.from = from
        self.holds = holds
        self.oversize = oversize
        self.refusal = refusal
        self.reproducible = reproducible
        self.retention = retention
        self.rows = rows
        self.share = share
        self.source = source
        self.subjects = subjects
        self.to = to
        self.version = version
    }

    public enum CodingKeys: String, CodingKey, CaseIterable {
        case dataset
        case digest
        case from
        case holds
        case oversize
        case refusal
        case reproducible
        case retention
        case rows
        case share
        case source
        case subjects
        case to
        case version
    }

    // Encodable protocol methods

    public func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encodeIfPresent(dataset, forKey: .dataset)
        try container.encodeIfPresent(digest, forKey: .digest)
        try container.encodeIfPresent(from, forKey: .from)
        try container.encodeIfPresent(holds, forKey: .holds)
        try container.encodeIfPresent(oversize, forKey: .oversize)
        try container.encodeIfPresent(refusal, forKey: .refusal)
        try container.encodeIfPresent(reproducible, forKey: .reproducible)
        try container.encodeIfPresent(retention, forKey: .retention)
        try container.encodeIfPresent(rows, forKey: .rows)
        try container.encodeIfPresent(share, forKey: .share)
        try container.encodeIfPresent(source, forKey: .source)
        try container.encodeIfPresent(subjects, forKey: .subjects)
        try container.encodeIfPresent(to, forKey: .to)
        try container.encodeIfPresent(version, forKey: .version)
    }
}