Files
sdk/include/hanzo/model/RiskLabelCoverage.h
zeekay 189ce08e51 Regenerate against the document the deployment answers for
The projection these were generated from was a month old and predated the
compute migration, so every one of them described /v1/visor — which the API
serves at zero paths now. That is why a hand-written console client and a
generated one had drifted the same way at the same time.

No /v1/visor path survives here. The word still appears as a source-plane
value and inside gvisor and supervisor, which are not this rename.
2026-09-05 18:07:13 -07:00

232 lines
9.2 KiB
C++

/**
* Hanzo Cloud API
* The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
*
* The version of the OpenAPI document: v1
*
* NOTE: This class is auto generated by OpenAPI-Generator 7.14.0.
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* RiskLabelCoverage.h
*
*
*/
#ifndef HANZO_MODEL_RiskLabelCoverage_H_
#define HANZO_MODEL_RiskLabelCoverage_H_
#include <boost/optional.hpp>
#include "hanzo/ModelBase.h"
#include <cpprest/details/basic_types.h>
#include "hanzo/model/RiskSourceCoverage.h"
#include <vector>
namespace hanzo {
namespace model {
class RiskSourceCoverage;
class RiskLabelCoverage
: public ModelBase
{
public:
RiskLabelCoverage();
virtual ~RiskLabelCoverage();
/////////////////////////////////////////////
/// ModelBase overrides
void validate() override;
web::json::value toJson() const override;
bool fromJson(const web::json::value& json) override;
void toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& namePrefix) const override;
bool fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& namePrefix) override;
/////////////////////////////////////////////
/// RiskLabelCoverage members
/// <summary>
/// Contested is how many matured events have two visible assertions that disagree. It is the number that says whether the precedence rule is load-bearing or decorative, and it is the one to watch after wiring a new source.
/// </summary>
int64_t getContested() const;
bool contestedIsSet() const;
void unsetContested();
void setContested(int64_t value);
/// <summary>
/// Events is how many DISTINCT judged events those assertions name, keyed on (kind, subject, at). It counts only events something was ASSERTED about: what share of the whole event stream carries a label is a question about the feature plane&#39;s denominator and is not answerable here. Matured + Unmatured is Events.
/// </summary>
int64_t getEvents() const;
bool eventsIsSet() const;
void unsetEvents();
void setEvents(int64_t value);
/// <summary>
/// Explore is the share of judged events whose winning assertion came from the below-the-line sample. A blocked transaction never produces a chargeback, so a training set with no exploration in it is a description of the incumbent block list rather than of the world — and a champion measured on it is measured on whether it agrees with the incumbent.
/// </summary>
double getExplore() const;
bool exploreIsSet() const;
void unsetExplore();
void setExplore(double value);
/// <summary>
/// Facts is how many assertions the window holds; Events is how many distinct judged events they cover. The two differ by exactly the corroboration and the conflict in the plane.
/// </summary>
int64_t getFacts() const;
bool factsIsSet() const;
void unsetFacts();
void setFacts(int64_t value);
/// <summary>
/// From is the INCLUSIVE start of the EVENT window these counts were folded over, RFC 3339, echoed with the defaults filled in — the caller&#39;s, or 90 days before To. An assertion is in the window when its event time satisfies at &gt;&#x3D; From.
/// </summary>
utility::string_t getFrom() const;
bool fromIsSet() const;
void unsetFrom();
void setFrom(const utility::string_t& value);
/// <summary>
/// Horizon is the maturity horizon these counts were measured under, IN DAYS — the caller&#39;s, or 120. It decides Matured (an event is matured when its &#x60;at&#x60; plus this many days is not after now), it sets each event&#39;s own as-of and so which assertions were visible to it, and when the caller bounds nothing it also places the default window&#39;s end.
/// </summary>
int64_t getHorizon() const;
bool horizonIsSet() const;
void unsetHorizon();
void setHorizon(int64_t value);
/// <summary>
/// Judged is how many MATURED events resolve, at their own as-of, to something other than unjudged.
/// </summary>
int64_t getJudged() const;
bool judgedIsSet() const;
void unsetJudged();
void setJudged(int64_t value);
/// <summary>
/// Matured is how many of those events have aged past the horizon and may therefore be admitted to a supervised set at all. It counts every matured event, judged or not — it is the DENOMINATOR an operator divides Judged by, and a denominator that excluded the unjudged would read 1.0 on a plane with one label in it.
/// </summary>
int64_t getMatured() const;
bool maturedIsSet() const;
void unsetMatured();
void setMatured(int64_t value);
/// <summary>
/// Pending is how many of this tenant&#39;s assertions the DERIVED columnar copy is not known to hold yet. Every count above is folded from the record, so they are right regardless — but a materialiser that joins in the warehouse while this is non-zero is joining against an incomplete answer key, and a missing fraud label is indistinguishable from an honest customer. It is reported at the training gate because that is where somebody is deciding whether the ground truth is good enough to fit on. Counted under a cap, so it saturates rather than costing a full scan on every read.
/// </summary>
int64_t getPending() const;
bool pendingIsSet() const;
void unsetPending();
void setPending(int64_t value);
/// <summary>
/// Productive is how many matured events resolve, at their own as-of, to a WINNING assertion of &#x60;productive&#x60; — the event led somewhere: escalated, reported, charged back. It is the positive class a supervised fit would train on, and a near-zero count is the number that says the fit is not worth running.
/// </summary>
int64_t getProductive() const;
bool productiveIsSet() const;
void unsetProductive();
void setProductive(int64_t value);
/// <summary>
/// Sources breaks the judged events down by the source that WON, so a plane that looks labelled because one noisy source dominates is visible as such.
/// </summary>
std::vector<std::shared_ptr<RiskSourceCoverage>> getSources() const;
bool sourcesIsSet() const;
void unsetSources();
void setSources(const std::vector<std::shared_ptr<RiskSourceCoverage>>& value);
/// <summary>
/// To is the EXCLUSIVE end of that window (at &lt; To). Unstated it is one horizon before now, never now: a window running to now under a maturity horizon can hold no matured event at all, so every count below would read zero however much ground truth the tenant held.
/// </summary>
utility::string_t getTo() const;
bool toIsSet() const;
void unsetTo();
void setTo(const utility::string_t& value);
/// <summary>
/// Unlabelled is how many MATURED events had no assertion knowable by their own as-of — including every assertion that arrived after that instant. It is the field that says WHY judged is low: a tenant whose ground truth was filed long after the events it judges reads matured&#x3D;n, judged&#x3D;0, unlabelled&#x3D;n, which is diagnosable, rather than a bare zero, which is not.
/// </summary>
int64_t getUnlabelled() const;
bool unlabelledIsSet() const;
void unsetUnlabelled();
void setUnlabelled(int64_t value);
/// <summary>
/// Unmatured is how many events in the window have NOT aged past the horizon. They are not unlabelled — they are not yet askable, and a supervised set must exclude them rather than treat them as negatives. Matured + Unmatured is Events.
/// </summary>
int64_t getUnmatured() const;
bool unmaturedIsSet() const;
void unsetUnmatured();
void setUnmatured(int64_t value);
/// <summary>
/// Unproductive is every OTHER judged event: the winner claimed &#x60;unproductive&#x60;, judged not suspicious. Productive + Unproductive is Judged exactly, because a winner of the explicit unjudged is counted in neither — it is a matured event somebody looked at and could not conclude about, and rolling it into the negatives would hand a model a claim nobody made.
/// </summary>
int64_t getUnproductive() const;
bool unproductiveIsSet() const;
void unsetUnproductive();
void setUnproductive(int64_t value);
protected:
int64_t m_Contested;
bool m_ContestedIsSet;
int64_t m_Events;
bool m_EventsIsSet;
double m_Explore;
bool m_ExploreIsSet;
int64_t m_Facts;
bool m_FactsIsSet;
utility::string_t m_From;
bool m_FromIsSet;
int64_t m_Horizon;
bool m_HorizonIsSet;
int64_t m_Judged;
bool m_JudgedIsSet;
int64_t m_Matured;
bool m_MaturedIsSet;
int64_t m_Pending;
bool m_PendingIsSet;
int64_t m_Productive;
bool m_ProductiveIsSet;
std::vector<std::shared_ptr<RiskSourceCoverage>> m_Sources;
bool m_SourcesIsSet;
utility::string_t m_To;
bool m_ToIsSet;
int64_t m_Unlabelled;
bool m_UnlabelledIsSet;
int64_t m_Unmatured;
bool m_UnmaturedIsSet;
int64_t m_Unproductive;
bool m_UnproductiveIsSet;
};
}
}
#endif /* HANZO_MODEL_RiskLabelCoverage_H_ */