mirror of
https://github.com/hanzo-cpp/sdk.git
synced 2026-11-20 19:55:32 +00:00
The projection was 113 commits behind the document it claims to describe, and `generate.py --all --check` reported every one of the thirteen clients DRIFTED — the same +19 models in each, because they all fell behind the same emission. Regenerated in place from hanzo-inc/cloud openapi.yaml at 939b09d4 (sha256 087024f6…), which is the only description of this API that cannot name a route the binary does not serve. `--check` is clean across all thirteen after. .spec-lock moved with the code. The generator READS that file and never writes it — hanzoai/ci`s lane does — so a hand run leaves every lock naming the previous document. A lock that disagrees with the tree beside it is worse than no lock: the next `--check` without `--spec` fetches what production serves, compares it to a digest that was already wrong, and reports drift that is really staleness.
207 lines
7.9 KiB
C++
207 lines
7.9 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.
|
|
*/
|
|
|
|
/*
|
|
* RiskLabelRecord.h
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifndef HANZO_MODEL_RiskLabelRecord_H_
|
|
#define HANZO_MODEL_RiskLabelRecord_H_
|
|
|
|
#include <boost/optional.hpp>
|
|
|
|
#include "hanzo/ModelBase.h"
|
|
|
|
#include <cpprest/details/basic_types.h>
|
|
|
|
namespace hanzo {
|
|
namespace model {
|
|
|
|
|
|
|
|
class RiskLabelRecord
|
|
: public ModelBase
|
|
{
|
|
public:
|
|
RiskLabelRecord();
|
|
virtual ~RiskLabelRecord();
|
|
|
|
/////////////////////////////////////////////
|
|
/// 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;
|
|
|
|
|
|
/////////////////////////////////////////////
|
|
/// RiskLabelRecord members
|
|
|
|
|
|
/// <summary>
|
|
/// At is when the judged EVENT happened, RFC 3339 in UTC, truncated to the second. The filer supplies it, and it is what a maturity horizon measures from: this event's as-of is At plus the horizon. A resolve names it back exactly, to the second.
|
|
/// </summary>
|
|
utility::string_t getAt() const;
|
|
bool atIsSet() const;
|
|
void unsetAt();
|
|
void setAt(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// By is the identity that asserted, stamped server-side at the write.
|
|
/// </summary>
|
|
utility::string_t getBy() const;
|
|
bool byIsSet() const;
|
|
void unsetBy();
|
|
void setBy(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Confidence is the filer's own confidence in [0,1] — 1 for a processor chargeback, less for an analyst's hunch. Zero is the ordinary value for a filer that stated none, and it means the weakest tie-break there is rather than \"unknown\". It breaks a tie only WITHIN one precedence rank and can never lift a weak source above a strong one.
|
|
/// </summary>
|
|
double getConfidence() const;
|
|
bool confidenceIsSet() const;
|
|
void unsetConfidence();
|
|
void setConfidence(double value);
|
|
|
|
/// <summary>
|
|
/// Disposition is what was concluded, from the closed set: `productive` — the event led somewhere, escalated, reported or charged back; `unproductive` — judged not suspicious; or the empty string for an explicit UNJUDGED, which is a real assertion (\"we looked and could not say\") and not the absence of one.
|
|
/// </summary>
|
|
utility::string_t getDisposition() const;
|
|
bool dispositionIsSet() const;
|
|
void unsetDisposition();
|
|
void setDisposition(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Evidence is the pointer to the record this conclusion came from: a dispute id, a case id, a decision id. At most 512 bytes, required at the write, and opaque to this plane — stored and returned verbatim, never resolved. It is what an adverse action is defended with, which is why an assertion carrying none is refused at the endpoint.
|
|
/// </summary>
|
|
utility::string_t getEvidence() const;
|
|
bool evidenceIsSet() const;
|
|
void unsetEvidence();
|
|
void setEvidence(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Hold is true while a litigation hold is on this record: retention will not dispose of it, at any age. False — and it is omitted then — leaves the record disposable once it is older than the boundary a sweep names. It is a fact about the RECORD and not about the world, so it is not folded into ID, no write path can set it, and the hold op is the one way it moves in either direction.
|
|
/// </summary>
|
|
bool isHold() const;
|
|
bool holdIsSet() const;
|
|
void unsetHold();
|
|
void setHold(bool value);
|
|
|
|
/// <summary>
|
|
/// ID is the assertion's content digest — SHA-256 over every semantic field, rendered hex — computed server-side and never supplied. It is the key a redelivery collapses onto, and it is the id the hold op names.
|
|
/// </summary>
|
|
utility::string_t getId() const;
|
|
bool idIsSet() const;
|
|
void unsetId();
|
|
void setId(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Kind is what the subject IS, from the closed set: account, agent, merchant, payout, person, session or transaction. With Subject and At it is the IDENTITY of the judged event — the triple a resolve names and the triple assertions are grouped by, so a typo in it would file a label against an event nobody asks about.
|
|
/// </summary>
|
|
utility::string_t getKind() const;
|
|
bool kindIsSet() const;
|
|
void unsetKind();
|
|
void setKind(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Knowable is when THIS PLANE could first have answered with the assertion: the later of Seen and the server clock at the write, derived server-side. It is the instant the leakage guard compares, so it is published beside the claim it was derived from — an answer whose rule nobody can see is one nobody can check.
|
|
/// </summary>
|
|
utility::string_t getKnowable() const;
|
|
bool knowableIsSet() const;
|
|
void unsetKnowable();
|
|
void setKnowable(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Seen is when the FILER said the assertion became knowable. It is provenance: it is recorded and published, and it decides nothing.
|
|
/// </summary>
|
|
utility::string_t getSeen() const;
|
|
bool seenIsSet() const;
|
|
void unsetSeen();
|
|
void setSeen(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Source is WHO asserted, from the closed set: chargeoff, dispute, case, refund, review or sample. It is the primary term of the precedence rule — an unknown source has no rank and a conflict with it could not be resolved — so it is what decides which of two disagreeing assertions is in force.
|
|
/// </summary>
|
|
utility::string_t getSource() const;
|
|
bool sourceIsSet() const;
|
|
void unsetSource();
|
|
void setSource(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Subject is the entity that was judged, named in the TENANT'S OWN namespace and at most 512 bytes. It is opaque here: stored, matched and returned verbatim, never dereferenced. It has no meaning outside this tenant — the record is the tenant's own file — so an id lifted from another tenant's response names nothing.
|
|
/// </summary>
|
|
utility::string_t getSubject() const;
|
|
bool subjectIsSet() const;
|
|
void unsetSubject();
|
|
void setSubject(const utility::string_t& value);
|
|
|
|
/// <summary>
|
|
/// Wrote is the server clock at the write. It is the only time on the record the tenant did not supply, and it is what retention measures against.
|
|
/// </summary>
|
|
utility::string_t getWrote() const;
|
|
bool wroteIsSet() const;
|
|
void unsetWrote();
|
|
void setWrote(const utility::string_t& value);
|
|
|
|
|
|
protected:
|
|
utility::string_t m_At;
|
|
bool m_AtIsSet;
|
|
|
|
utility::string_t m_By;
|
|
bool m_ByIsSet;
|
|
|
|
double m_Confidence;
|
|
bool m_ConfidenceIsSet;
|
|
|
|
utility::string_t m_Disposition;
|
|
bool m_DispositionIsSet;
|
|
|
|
utility::string_t m_Evidence;
|
|
bool m_EvidenceIsSet;
|
|
|
|
bool m_Hold;
|
|
bool m_HoldIsSet;
|
|
|
|
utility::string_t m_Id;
|
|
bool m_IdIsSet;
|
|
|
|
utility::string_t m_Kind;
|
|
bool m_KindIsSet;
|
|
|
|
utility::string_t m_Knowable;
|
|
bool m_KnowableIsSet;
|
|
|
|
utility::string_t m_Seen;
|
|
bool m_SeenIsSet;
|
|
|
|
utility::string_t m_Source;
|
|
bool m_SourceIsSet;
|
|
|
|
utility::string_t m_Subject;
|
|
bool m_SubjectIsSet;
|
|
|
|
utility::string_t m_Wrote;
|
|
bool m_WroteIsSet;
|
|
|
|
};
|
|
|
|
|
|
}
|
|
}
|
|
|
|
#endif /* HANZO_MODEL_RiskLabelRecord_H_ */
|