Files
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

128 lines
6.5 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.
*/
/*
* ReferenceApi.h
*
*
*/
#ifndef HANZO_API_ReferenceApi_H_
#define HANZO_API_ReferenceApi_H_
#include "hanzo/ApiClient.h"
#include "hanzo/model/ClearReferenceOut.h"
#include "hanzo/model/ReferenceOut.h"
#include "hanzo/model/ReferenceSetsOut.h"
#include "hanzo/model/RefreshReferenceIn.h"
#include "hanzo/model/RefreshReferenceOut.h"
#include "hanzo/model/ResolveReferenceIn.h"
#include "hanzo/model/ResolveReferenceOut.h"
#include "hanzo/model/SetReferenceIn.h"
#include "hanzo/model/SetReferenceOut.h"
#include <cpprest/details/basic_types.h>
#include <boost/optional.hpp>
namespace hanzo {
namespace api {
using namespace hanzo::model;
class ReferenceApi
{
public:
explicit ReferenceApi( std::shared_ptr<const ApiClient> apiClient );
virtual ~ReferenceApi();
/// <summary>
/// Removes one of your organisation&#39;s overrides.
/// </summary>
/// <remarks>
/// Removes one of your organisation&#39;s overrides. It removes an entry your organisation wrote, never a baseline member: the published set is not writable from here, so a removal can only ever restore the baseline&#39;s own answer.
/// </remarks>
/// <param name="set"></param>
/// <param name="key"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<ClearReferenceOut>> riskClearReference(
utility::string_t set,
boost::optional<utility::string_t> key
) const;
/// <summary>
/// Reference describes one set and lists your org&#39;s overrides in it.
/// </summary>
/// <remarks>
/// Reference describes one set and lists your org&#39;s overrides in it. The set half is public data about a published list — its version, its publishers, their licences and how current each one is. The overrides half is yours alone: it is read from your organisation&#39;s own store, and no other organisation&#39;s entries can appear in it.
/// </remarks>
/// <param name="set"></param>
/// <param name="after">After pages the override listing: the last key of the previous page. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="limit">Limit caps the override listing: default 200, maximum 1000. (optional, default to 0L)</param>
pplx::task<std::shared_ptr<ReferenceOut>> riskReference(
utility::string_t set,
boost::optional<utility::string_t> after,
boost::optional<int64_t> limit
) const;
/// <summary>
/// Lists every set this plane publishes, with its version and how fresh it is.
/// </summary>
/// <remarks>
/// Lists every set this plane publishes, with its version and how fresh it is. Read the Stale and Refused lists first: they are the two ways this plane can be quietly wrong, and they are reported rather than inferred. A set in Refused answers nothing — it has never loaded, it is held by another component, or it names a source we hold no licence for.
/// </remarks>
pplx::task<std::shared_ptr<ReferenceSetsOut>> riskReferenceSets(
) const;
/// <summary>
/// Takes a new version of one set.
/// </summary>
/// <remarks>
/// Takes a new version of one set. SuperAdmin only. It is platform work, not tenant work: it writes the shared baseline every organisation reads, so it is gated to the platform&#39;s own identity. Nothing here can write an organisation&#39;s overrides, and nothing an organisation sends can reach this route. Idempotent. A version is the content digest of what was taken, so refreshing an unchanged publisher writes no rows and reports unchanged. Resumable: a run that died half-way is continued from where it stopped rather than restarted. A set whose source needs a licence we do not hold is refused with the reason, rather than being quietly skipped.
/// </remarks>
/// <param name="refreshReferenceIn"></param>
pplx::task<std::shared_ptr<RefreshReferenceOut>> riskRefreshReference(
std::shared_ptr<RefreshReferenceIn> refreshReferenceIn
) const;
/// <summary>
/// Looks keys up against the reference plane.
/// </summary>
/// <remarks>
/// Looks keys up against the reference plane. Your organisation&#39;s own overrides are consulted FIRST and win outright; the shared baseline answers everything they do not cover. Every answer names the version that produced it, when that version was current and whether it is stale, so a decision can record exactly what it consulted. Read Refusal before reading Hit. A set that has never loaded, one held by the component that screens against it, and one whose source needs a licence we do not hold all answer with a refusal — and a miss on a refusing set means nothing is known, not that the key is clean.
/// </remarks>
/// <param name="resolveReferenceIn"></param>
pplx::task<std::shared_ptr<ResolveReferenceOut>> riskResolveReference(
std::shared_ptr<ResolveReferenceIn> resolveReferenceIn
) const;
/// <summary>
/// Writes your organisation&#39;s own allow and deny entries over a set.
/// </summary>
/// <remarks>
/// Writes your organisation&#39;s own allow and deny entries over a set. Idempotent on the key: writing the same entry twice is one entry, and writing it again replaces the verdict and the note. The whole batch is one transaction, so a batch that would cross the per-set bound writes nothing rather than half of itself — a half-applied deny list is worse than a refused one, because nobody can tell which half applied. Your entries are held in your organisation&#39;s own store and are never visible to another organisation, and they never change what any other organisation sees. The shared baseline is not writable from here at all.
/// </remarks>
/// <param name="set"></param>
/// <param name="setReferenceIn"></param>
pplx::task<std::shared_ptr<SetReferenceOut>> riskSetReference(
utility::string_t set,
std::shared_ptr<SetReferenceIn> setReferenceIn
) const;
protected:
std::shared_ptr<const ApiClient> m_ApiClient;
};
}
}
#endif /* HANZO_API_ReferenceApi_H_ */