mirror of
https://github.com/hanzo-cpp/sdk.git
synced 2026-11-20 19:55:32 +00:00
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.
128 lines
6.5 KiB
C++
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's overrides.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Removes one of your organisation'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's own answer.
|
|
/// </remarks>
|
|
/// <param name="set"></param>
|
|
/// <param name="key"> (optional, default to utility::conversions::to_string_t(""))</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's overrides in it.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Reference describes one set and lists your org'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's own store, and no other organisation'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(""))</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's own identity. Nothing here can write an organisation'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'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's own allow and deny entries over a set.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Writes your organisation'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'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_ */
|
|
|