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

1766 lines
116 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.
*/
/*
* IamApi.h
*
*
*/
#ifndef HANZO_API_IamApi_H_
#define HANZO_API_IamApi_H_
#include "hanzo/ApiClient.h"
#include "hanzo/AnyType.h"
#include "hanzo/model/Iam_Answer.h"
#include "hanzo/model/Iam_Application.h"
#include "hanzo/model/Iam_ApplicationListResult.h"
#include "hanzo/model/Iam_AuditLog.h"
#include "hanzo/model/Iam_Cert.h"
#include "hanzo/model/Iam_CreateInput.h"
#include "hanzo/model/Iam_CreateOrganizationInput.h"
#include "hanzo/model/Iam_CreateSessionIn.h"
#include "hanzo/model/Iam_DeleteOrganizationOutput.h"
#include "hanzo/model/Iam_DeleteOutput.h"
#include "hanzo/model/Iam_DeleteResponse.h"
#include "hanzo/model/Iam_DeleteResult.h"
#include "hanzo/model/Iam_DeleteSessionOut.h"
#include "hanzo/model/Iam_Input.h"
#include "hanzo/model/Iam_Invitation.h"
#include "hanzo/model/Iam_Key.h"
#include "hanzo/model/Iam_ListOrganizationsOutput.h"
#include "hanzo/model/Iam_ListOutput.h"
#include "hanzo/model/Iam_ListResponse.h"
#include "hanzo/model/Iam_ListSessionsOut.h"
#include "hanzo/model/Iam_Organization.h"
#include "hanzo/model/Iam_Permission.h"
#include "hanzo/model/Iam_Project.h"
#include "hanzo/model/Iam_Provider.h"
#include "hanzo/model/Iam_Role.h"
#include "hanzo/model/Iam_Session.h"
#include "hanzo/model/Iam_SetAvatarInput.h"
#include "hanzo/model/Iam_SetProfileInput.h"
#include "hanzo/model/Iam_Team.h"
#include "hanzo/model/Iam_Token.h"
#include "hanzo/model/Iam_UpdateInput.h"
#include "hanzo/model/Iam_UpdateOrganizationInput.h"
#include "hanzo/model/Iam_UpdateSessionIn.h"
#include "hanzo/model/Iam_User.h"
#include "hanzo/model/Iam_WebauthnCredential.h"
#include "hanzo/model/Iam_Workspace.h"
#include "hanzo/model/Iam_accountBody.h"
#include "hanzo/model/Iam_assumeBody.h"
#include "hanzo/model/Iam_certs_DeleteOutput.h"
#include "hanzo/model/Iam_certs_ListOutput.h"
#include "hanzo/model/Iam_config.h"
#include "hanzo/model/Iam_invitations_DeleteOutput.h"
#include "hanzo/model/Iam_invitations_Input.h"
#include "hanzo/model/Iam_invitations_ListOutput.h"
#include "hanzo/model/Iam_listProvidersOut.h"
#include "hanzo/model/Iam_listResponse.h"
#include "hanzo/model/Iam_listTokensOut.h"
#include "hanzo/model/Iam_listWebauthnCredentialsOut.h"
#include "hanzo/model/Iam_mutationResult.h"
#include "hanzo/model/Iam_passwordBody.h"
#include "hanzo/model/Iam_permission_DeleteResponse.h"
#include "hanzo/model/Iam_permission_ListResponse.h"
#include "hanzo/model/Iam_person.h"
#include "hanzo/model/Iam_projects_DeleteOutput.h"
#include "hanzo/model/Iam_projects_Input.h"
#include "hanzo/model/Iam_projects_ListOutput.h"
#include "hanzo/model/Iam_providerResult.h"
#include "hanzo/model/Iam_registration.h"
#include "hanzo/model/Iam_reply.h"
#include "hanzo/model/Iam_roles_DeleteOutput.h"
#include "hanzo/model/Iam_roles_Input.h"
#include "hanzo/model/Iam_roles_ListOutput.h"
#include "hanzo/model/Iam_teams_DeleteOutput.h"
#include "hanzo/model/Iam_teams_Input.h"
#include "hanzo/model/Iam_teams_ListOutput.h"
#include "hanzo/model/Iam_tokenMutation.h"
#include "hanzo/model/Iam_tokenResult.h"
#include "hanzo/model/Iam_users_DeleteOutput.h"
#include "hanzo/model/Iam_users_ListOutput.h"
#include "hanzo/model/Iam_webauthnCredentialMutationResult.h"
#include "hanzo/model/Iam_webauthnCredentialResult.h"
#include "hanzo/model/Iam_workspaces_DeleteOutput.h"
#include "hanzo/model/Iam_workspaces_Input.h"
#include "hanzo/model/Iam_workspaces_ListOutput.h"
#include <cpprest/details/basic_types.h>
#include <boost/optional.hpp>
namespace hanzo {
namespace api {
using namespace hanzo::model;
class IamApi
{
public:
explicit IamApi( std::shared_ptr<const ApiClient> apiClient );
virtual ~IamApi();
/// <summary>
/// Adds an identity provider your people can sign in with, or a service your applications send through — a social or enterprise login, an email or SMS sender, a storage or payment connector.
/// </summary>
/// <remarks>
/// Adds an identity provider your people can sign in with, or a service your applications send through — a social or enterprise login, an email or SMS sender, a storage or payment connector. A provider is configured once and then switched on per application, so several applications can share one set of credentials.
/// </remarks>
/// <param name="iamProvider"></param>
pplx::task<std::shared_ptr<Iam_providerResult>> addProvider(
std::shared_ptr<Iam_Provider> iamProvider
) const;
/// <summary>
/// Records an access token — the credential an application or integration presents on a caller&#39;s behalf.
/// </summary>
/// <remarks>
/// Records an access token — the credential an application or integration presents on a caller&#39;s behalf.
/// </remarks>
/// <param name="iamToken"></param>
pplx::task<std::shared_ptr<Iam_tokenResult>> addToken(
std::shared_ptr<Iam_Token> iamToken
) const;
/// <summary>
/// Registers a passkey or security key for a person, so they can sign in with their device instead of a password.
/// </summary>
/// <remarks>
/// Registers a passkey or security key for a person, so they can sign in with their device instead of a password.
/// </remarks>
/// <param name="iamWebauthnCredential"></param>
pplx::task<std::shared_ptr<Iam_webauthnCredentialResult>> addWebauthnCredential(
std::shared_ptr<Iam_WebauthnCredential> iamWebauthnCredential
) const;
/// <summary>
/// Makes a new organization — the account your users, applications, roles, projects and workspaces are all named inside.
/// </summary>
/// <remarks>
/// Makes a new organization — the account your users, applications, roles, projects and workspaces are all named inside. It is the first write in a new tenant, and a name already in use is refused rather than taken over.
/// </remarks>
/// <param name="iamCreateOrganizationInput"></param>
pplx::task<std::shared_ptr<Iam_Organization>> createOrganization(
std::shared_ptr<Iam_CreateOrganizationInput> iamCreateOrganizationInput
) const;
/// <summary>
/// Records a sign-in and answers with the cookie id it minted.
/// </summary>
/// <remarks>
/// Records a sign-in and answers with the cookie id it minted. Signing in again from another browser adds to the session rather than replacing it, so one person can be signed in from a laptop and a phone at once. Ask for an exclusive sign-in and the opposite holds: the new sign-in is the only one left and every other browser is signed out. That is the setting to use when one person may hold only one live session at a time.
/// </remarks>
/// <param name="iamCreateSessionIn"></param>
pplx::task<std::shared_ptr<Iam_Session>> createSession(
std::shared_ptr<Iam_CreateSessionIn> iamCreateSessionIn
) const;
/// <summary>
/// Removes an application.
/// </summary>
/// <remarks>
/// Removes an application. Anyone mid-sign-in through it is turned away and its client credentials stop working, so retire the integration before deleting it.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_DeleteResult>> deleteIamApplicationsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes an audit entry.
/// </summary>
/// <remarks>
/// Removes an audit entry. Retention policy is normally what should expire a trail; deleting by hand leaves a gap a reviewer will notice.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_DeleteOutput>> deleteIamAuditLogsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes a signing certificate.
/// </summary>
/// <remarks>
/// Removes a signing certificate. Tokens signed with it can no longer be verified, so retire it only once nothing is still presenting them.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_certs_DeleteOutput>> deleteIamCertsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Withdraws an invitation.
/// </summary>
/// <remarks>
/// Withdraws an invitation. It stops being redeemable at once; anyone who already joined through it keeps their account.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_invitations_DeleteOutput>> deleteIamInvitationsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Revokes an API key.
/// </summary>
/// <remarks>
/// Revokes an API key. Anything still presenting it stops being authorized at once, so roll the replacement out before you revoke.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_DeleteResponse>> deleteIamKeysByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Turns a factor off, so sign-in stops asking for it.
/// </summary>
/// <remarks>
/// Turns a factor off, so sign-in stops asking for it. Naming no factor turns off ALL of them — the reset path. People may do this for themselves; doing it for somebody else takes an administrator, which is what makes it the way back in when a phone is lost. The recovery codes go with the last factor: they are the way past a challenge, so keeping them alive for an account with nothing to challenge would leave a standing credential behind.
/// </remarks>
pplx::task<void> deleteIamMfa(
) const;
/// <summary>
/// Revokes a permission.
/// </summary>
/// <remarks>
/// Revokes a permission. Everyone who held access only through it loses that access immediately; grants they hold by another route are untouched.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_permission_DeleteResponse>> deleteIamPermissionsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes a project.
/// </summary>
/// <remarks>
/// Removes a project. The people and roles in your organization are unchanged; what goes is the scope itself, so move anything addressed by it first.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_projects_DeleteOutput>> deleteIamProjectsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes a role.
/// </summary>
/// <remarks>
/// Removes a role. Everyone in it loses the access it carried; their accounts, and any other role they hold, are untouched.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_roles_DeleteOutput>> deleteIamRolesByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Deprovisions a person — how removing someone in your identity provider removes their access here.
/// </summary>
/// <remarks>
/// Deprovisions a person — how removing someone in your identity provider removes their access here. Their sessions stop working immediately. Takes an administrator.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<void> deleteIamScimV2UsersByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Serves DELETE /v1/iam/service-accounts/:name.
/// </summary>
/// <remarks>
/// Serves DELETE /v1/iam/service-accounts/:name.
/// </remarks>
/// <param name="name"></param>
pplx::task<void> deleteIamServiceAccountsByName(
utility::string_t name
) const;
/// <summary>
/// Removes a team.
/// </summary>
/// <remarks>
/// Removes a team. Everyone in it loses the access it carried; their accounts, and any other team they are in, are untouched.
/// </remarks>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_teams_DeleteOutput>> deleteIamTeamsByName(
utility::string_t name
) const;
/// <summary>
/// Removes a person from your organization.
/// </summary>
/// <remarks>
/// Removes a person from your organization. Their sessions stop working immediately and the account is gone rather than suspended — to keep the record and only stop sign-in, update the user instead.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_users_DeleteOutput>> deleteIamUsersByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Clears the target user&#39;s key of the requested TYPE (immediate revoke).
/// </summary>
/// <remarks>
/// Clears the target user&#39;s key of the requested TYPE (immediate revoke). Scoped by the same &#x60;?type&#x60; field mint takes, so revoking the browser key leaves the server key working. A secret key&#39;s stored value is the sk- in its schema.Key row.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<void> deleteIamUsersByOwnerByNameKeys(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes a workspace.
/// </summary>
/// <remarks>
/// Removes a workspace. The people and roles in your organization are unchanged; what goes is the scope itself.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_workspaces_DeleteOutput>> deleteIamWorkspacesByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes an organization and everything named inside it.
/// </summary>
/// <remarks>
/// Removes an organization and everything named inside it. There is no undo, and every session issued under it stops working. The built-in admin organization cannot be deleted — losing it would leave the account with no way back in.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_DeleteOrganizationOutput>> deleteOrganization(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes a provider.
/// </summary>
/// <remarks>
/// Removes a provider. Sign-in through it stops for every application that used it, so give those applications another method first. A provider that is already gone answers \&quot;nothing changed\&quot; rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_mutationResult>> deleteProvider(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Signs a person out of one application — the session ends and every browser carrying it stops being authenticated.
/// </summary>
/// <remarks>
/// Signs a person out of one application — the session ends and every browser carrying it stops being authenticated. A session that is already gone reports that nothing was deleted rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="application"></param>
pplx::task<std::shared_ptr<Iam_DeleteSessionOut>> deleteSession(
utility::string_t owner,
utility::string_t name,
utility::string_t application
) const;
/// <summary>
/// Revokes an access token.
/// </summary>
/// <remarks>
/// Revokes an access token. Whatever was using it stops being authorized at once. A token that is already gone answers \&quot;nothing changed\&quot; rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_tokenMutation>> deleteToken(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Removes a passkey or security key — what you call when a device is lost.
/// </summary>
/// <remarks>
/// Removes a passkey or security key — what you call when a device is lost. Make sure the person has another way to sign in first. A credential that is already gone answers \&quot;nothing changed\&quot; rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_webauthnCredentialMutationResult>> deleteWebauthnCredential(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns the signed-in person&#39;s own account and the organization they belong to — what a console reads to draw the account menu.
/// </summary>
/// <remarks>
/// Returns the signed-in person&#39;s own account and the organization they belong to — what a console reads to draw the account menu. Passwords, API secrets and MFA material are stripped. It answers for a session cookie or a bearer token alike.
/// </remarks>
pplx::task<void> getIamAccount(
) const;
/// <summary>
/// Returns the applications in one organization, newest first — each product or site your people sign in to, with the sign-in methods and redirect URIs it allows.
/// </summary>
/// <remarks>
/// Returns the applications in one organization, newest first — each product or site your people sign in to, with the sign-in methods and redirect URIs it allows.
/// </remarks>
/// <param name="owner"></param>
pplx::task<std::shared_ptr<Iam_ApplicationListResult>> getIamApplications(
utility::string_t owner
) const;
/// <summary>
/// Returns one application: its sign-in methods, its allowed redirect URIs and the client credentials your integration authenticates with.
/// </summary>
/// <remarks>
/// Returns one application: its sign-in methods, its allowed redirect URIs and the client credentials your integration authenticates with.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Application>> getIamApplicationsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns your organization&#39;s audit trail, newest first — who did what, when, and from where.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s audit trail, newest first — who did what, when, and from where. It is the record you reach for during a security review or an incident. You see your own organization&#39;s audit trail and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_ListOutput>> getIamAuditLogs(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one audit entry in full: the action, the person or key behind it, and the request it came in on.
/// </summary>
/// <remarks>
/// Returns one audit entry in full: the action, the person or key behind it, and the request it came in on.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_AuditLog>> getIamAuditLogsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns everything a login screen needs to draw itself for one application: its branding, and each sign-in method it offers with the provider details that method needs.
/// </summary>
/// <remarks>
/// Returns everything a login screen needs to draw itself for one application: its branding, and each sign-in method it offers with the provider details that method needs. The client secret is masked. Read before anyone has signed in, so it carries only what is safe for a browser to see.
/// </remarks>
/// <param name="clientId">ClientId is the application&#39;s OAuth client id — the one field that selects which login screen this is. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="responseType">ResponseType is the OAuth response type the screen will ask for. Only \&quot;code\&quot; is served; anything else is refused here rather than at the authorize leg, where the person has already typed a password. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> getIamAuthApplication(
boost::optional<utility::string_t> clientId,
boost::optional<utility::string_t> responseType
) const;
/// <summary>
/// Returns the sign-in methods one application actually has switched on, so a login screen can render the right buttons for it without you hard-coding a list that drifts the moment you add a provider.
/// </summary>
/// <remarks>
/// Returns the sign-in methods one application actually has switched on, so a login screen can render the right buttons for it without you hard-coding a list that drifts the moment you add a provider. Public by design: it is read before anyone has signed in, and it exposes only which methods exist, never their credentials.
/// </remarks>
/// <param name="clientId">ClientId is the application&#39;s OAuth client id. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> getIamAuthMethods(
boost::optional<utility::string_t> clientId
) const;
/// <summary>
/// Returns your organization&#39;s signing certificates, newest first — the keys the tokens your applications verify are signed with.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s signing certificates, newest first — the keys the tokens your applications verify are signed with. Private key material is masked. You see your own organization&#39;s certificates and no one else&#39;s; which organization that is comes from your credentials, not from the request, so a query parameter can never widen the listing.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_certs_ListOutput>> getIamCerts(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one signing certificate — its algorithm, its validity window and its public half.
/// </summary>
/// <remarks>
/// Returns one signing certificate — its algorithm, its validity window and its public half. The private key is masked.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Cert>> getIamCertsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns the calling person&#39;s own privacy and communication choices.
/// </summary>
/// <remarks>
/// Returns the calling person&#39;s own privacy and communication choices. Somebody who has never set them gets the defaults rather than nothing, so a consent screen always has something to show — insights on, and training UNANSWERED, which is the state that means the screen still has to ask.
/// </remarks>
pplx::task<void> getIamConsent(
) const;
/// <summary>
/// Returns your organization&#39;s invitations, newest first — who has been asked to join, on what terms, and how many seats each invitation still has left.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s invitations, newest first — who has been asked to join, on what terms, and how many seats each invitation still has left. You see your own organization&#39;s invitations and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_invitations_ListOutput>> getIamInvitations(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one invitation: who it is for, what it grants on acceptance, and when it expires.
/// </summary>
/// <remarks>
/// Returns one invitation: who it is for, what it grants on acceptance, and when it expires.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Invitation>> getIamInvitationsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns an organization&#39;s API keys, newest first — what each is called, what it may reach, and its publishable half.
/// </summary>
/// <remarks>
/// Returns an organization&#39;s API keys, newest first — what each is called, what it may reach, and its publishable half. Secret halves are never listed. Which organization comes from your credentials, not from the request: you read your own and no one else&#39;s. The capability that admits a confidential client to this collection does not itself name a tenant, so the tenant is decided here.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_ListResponse>> getIamKeys(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one API key: what it is called, what it may reach, and when it was issued.
/// </summary>
/// <remarks>
/// Returns one API key: what it is called, what it may reach, and when it was issued.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Key>> getIamKeysByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Resolve a PUBLISHABLE key to the organization that owns it
/// </summary>
/// <remarks>
/// Answers which organization a publishable key belongs to — what a service calls to attribute a request that arrived carrying a key shipped in a browser. This is the noun spelling of &#x60;/v1/iam/resolve-key&#x60;, the same handler at the address that replaces it; both answer while callers migrate. It names an ORGANIZATION and never a person. No path through it loads or returns a user, so a key placed in client code cannot become a way to learn who anyone is — which is the whole reason this is a separate endpoint from the one below. A key that is expired, secret rather than publishable, or simply unknown all answer with the same sentence and a &#x60;code&#x60; saying which it was. Only a confidential service that has already proved it may resolve keys reads that code — there is no anonymous caller here to probe which keys exist — and telling those apart is what lets a holder be told to re-mint an expired key instead of hunting a configuration error.
/// </remarks>
pplx::task<void> getIamKeysOrg(
) const;
/// <summary>
/// Resolve a SECRET key to the principal it authenticates
/// </summary>
/// <remarks>
/// Answers who a secret key belongs to — the owner and name a gateway needs to attribute and bill a request that arrived carrying an &#x60;sk-&#x60;. This is the noun spelling of &#x60;/v1/iam/get-user?accessKey&#x3D;&#x60;, the same handler at the address that replaces it; both answer while callers migrate. It resolves a KEY and nothing else. The verb it replaces also reads a user by &#x60;?id&#x3D;&#x60;, and carrying that here would make this a second address for the user read — the exact thing being retired. Ask for a person by name at the user read; ask here only what a credential resolves to. Requires a confidential caller: the resolver authenticates as an app, so a request without that credential resolves nothing rather than falling back to an anonymous lookup. An unresolvable key answers with a &#x60;code&#x60; distinguishing expired from wrong-endpoint from unknown, so the holder can be told which one cure applies.
/// </remarks>
pplx::task<void> getIamKeysPrincipal(
) const;
/// <summary>
/// Returns the sign-in identities linked to the calling person&#39;s account — every provider they can currently sign in with.
/// </summary>
/// <remarks>
/// Returns the sign-in identities linked to the calling person&#39;s account — every provider they can currently sign in with. It is what a security page lists next to the option to disconnect one.
/// </remarks>
pplx::task<void> getIamLinkedAccounts(
) const;
/// <summary>
/// Answers either question about who belongs where: which organizations one person can act in, or who can act in one organization.
/// </summary>
/// <remarks>
/// Answers either question about who belongs where: which organizations one person can act in, or who can act in one organization. Both are org-scoped: a non-SuperAdmin may ask about ITS OWN org&#39;s roster, or about a user whose home org is its own, and nothing else. The bound comes from the verified credential via principal.Scope, so a request parameter can never widen it — a membership row names who may act and spend in an org, so a cross-tenant read is a customer roster leak.
/// </remarks>
/// <param name="user">User is \&quot;&lt;homeOrg&gt;/&lt;username&gt;\&quot; — which organizations that identity may act in. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="org">Org is an organization — who may act in it. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> getIamMemberships(
boost::optional<utility::string_t> user,
boost::optional<utility::string_t> org
) const;
/// <summary>
/// Starts a sign-in — the address you send a browser to, and the beginning of every OAuth and OpenID Connect flow.
/// </summary>
/// <remarks>
/// Starts a sign-in — the address you send a browser to, and the beginning of every OAuth and OpenID Connect flow. If the person is ALREADY signed in here, it does not ask them again: it returns them to the application with a one-time code and they never see this page. Otherwise it shows the right way to sign in for the application they are signing in to, or hands off to another identity provider if that is what they pick. A client can say what it wants with &#x60;prompt&#x60;: &#x60;none&#x60; means answer without any screen at all — with the code if a session exists, with an error if not, but never with a page; &#x60;login&#x60; means ask for the password again even if a session exists; &#x60;select_account&#x60; means let the person choose which identity to use. It returns only to an address the application has registered. That check happens before anything else, so a request naming an unregistered address is refused where the person can see it rather than being bounced onwards.
/// </remarks>
pplx::task<void> getIamOauthAuthorize(
) const;
/// <summary>
/// Completes the round-trip: it resolves and burns the single-use transaction (checking expiry + browser binding), exchanges and verifies the IdP response, links or provisions the local user, and mints the iam authorization code the relying party expects — then redirects to the original redirect_uri with code + state.
/// </summary>
/// <remarks>
/// Completes the round-trip: it resolves and burns the single-use transaction (checking expiry + browser binding), exchanges and verifies the IdP response, links or provisions the local user, and mints the iam authorization code the relying party expects — then redirects to the original redirect_uri with code + state.
/// </remarks>
pplx::task<void> getIamOauthCallback(
) const;
/// <summary>
/// Ends a sign-in and sends the browser somewhere sensible.
/// </summary>
/// <remarks>
/// Ends a sign-in and sends the browser somewhere sensible. Accepts GET or POST, so it works as a plain link. It ACTUALLY signs you out — worth stating, because a logout that computes a redirect and answers {\&quot;status\&quot;:\&quot;ok\&quot;} while ending no session and revoking no token is worse than none: the person on the shared machine believes it worked. Three things happen here, in this order: 1. The browser session dies — sid revoked server-side AND the cookie expired (sessions.Clear). Server-side revocation is the load-bearing half: a copy of the cookie taken before logout must not still resolve. 2. The relying party&#39;s tokens are revoked when an id_token_hint names it, so the refresh token cannot mint a fresh access token after the human left. Revocation state is authoritative — a JWT&#39;s &#x60;exp&#x60; still reads valid for days, so expiry is necessary but never sufficient. 3. Only then is a redirect considered, and only to a REGISTERED uri. The open-redirect guard is unchanged: a redirect happens only when a VERIFIED id_token_hint identifies the application and that application has registered the target. Anything else refuses to redirect — nobody can turn your logout link into a redirect to a site of their choosing.
/// </remarks>
pplx::task<void> getIamOauthLogout(
) const;
/// <summary>
/// Returns the profile claims for whoever the access token belongs to — the standard OpenID Connect way to find out who is calling you without your application storing anything itself.
/// </summary>
/// <remarks>
/// Returns the profile claims for whoever the access token belongs to — the standard OpenID Connect way to find out who is calling you without your application storing anything itself. The token must still be live: revoke it and this stops answering.
/// </remarks>
pplx::task<void> getIamOauthUserinfo(
) const;
/// <summary>
/// Returns the permissions in one organization, newest first — each one a grant saying which people or roles may do what, and to which resources.
/// </summary>
/// <remarks>
/// Returns the permissions in one organization, newest first — each one a grant saying which people or roles may do what, and to which resources.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_permission_ListResponse>> getIamPermissions(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one permission: who it grants to, what it allows, and the resources it covers.
/// </summary>
/// <remarks>
/// Returns one permission: who it grants to, what it allows, and the resources it covers.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Permission>> getIamPermissionsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns your organization&#39;s projects, newest first — the scope people pick between when their work is separated by product or client rather than by team.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s projects, newest first — the scope people pick between when their work is separated by product or client rather than by team. You see your own organization&#39;s projects and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_projects_ListOutput>> getIamProjects(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one project: what it is called and how it is set up.
/// </summary>
/// <remarks>
/// Returns one project: what it is called and how it is set up.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Project>> getIamProjectsByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Publishes the public key your registry uses to verify the tokens issued above — the one URL to configure so the registry trusts logins without holding any secret of its own.
/// </summary>
/// <remarks>
/// Publishes the public key your registry uses to verify the tokens issued above — the one URL to configure so the registry trusts logins without holding any secret of its own. If no signing key is available it refuses rather than publishing an empty set, because a registry that trusts nothing looks identical to one that trusts everything until somebody tries to push.
/// </remarks>
pplx::task<void> getIamRegistryJwks(
) const;
/// <summary>
/// Signs a container client in to your registry.
/// </summary>
/// <remarks>
/// Signs a container client in to your registry. &#x60;docker login&#x60;, and every build tool that pushes or pulls images, lands here: it exchanges the credential for a short-lived token scoped to exactly the repositories that credential may touch. Both of the shapes container tooling uses are accepted, so the same login works whichever client your pipeline runs.
/// </remarks>
pplx::task<void> getIamRegistryToken(
) const;
/// <summary>
/// Returns your organization&#39;s roles, newest first — each a named group of people that permissions are granted to.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s roles, newest first — each a named group of people that permissions are granted to. You see your own organization&#39;s roles and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_roles_ListOutput>> getIamRoles(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one role: who is in it, and the roles it includes.
/// </summary>
/// <remarks>
/// Returns one role: who is in it, and the roles it includes.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Role>> getIamRolesByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns the kinds of record this directory provisions and the address of each, so your identity provider discovers them rather than having them configured by hand.
/// </summary>
/// <remarks>
/// Returns the kinds of record this directory provisions and the address of each, so your identity provider discovers them rather than having them configured by hand.
/// </remarks>
pplx::task<std::shared_ptr<Iam_listResponse>> getIamScimV2Resourcetypes(
) const;
/// <summary>
/// Returns one provisionable record kind in full.
/// </summary>
/// <remarks>
/// Returns one provisionable record kind in full.
/// </remarks>
/// <param name="name"></param>
pplx::task<std::shared_ptr<AnyType>> getIamScimV2ResourcetypesByName(
utility::string_t name
) const;
/// <summary>
/// Returns the attribute definitions this directory understands, so your identity provider knows which fields it may send and what they mean before it sends any.
/// </summary>
/// <remarks>
/// Returns the attribute definitions this directory understands, so your identity provider knows which fields it may send and what they mean before it sends any.
/// </remarks>
pplx::task<std::shared_ptr<Iam_listResponse>> getIamScimV2Schemas(
) const;
/// <summary>
/// Returns one attribute definition in full.
/// </summary>
/// <remarks>
/// Returns one attribute definition in full.
/// </remarks>
/// <param name="id"></param>
pplx::task<std::shared_ptr<AnyType>> getIamScimV2SchemasById(
utility::string_t id
) const;
/// <summary>
/// Tells your identity provider which parts of SCIM this directory supports, so it configures itself instead of you filling in a form.
/// </summary>
/// <remarks>
/// Tells your identity provider which parts of SCIM this directory supports, so it configures itself instead of you filling in a form. Filtering and partial updates are supported. Bulk operations, sorting and entity tags are not — an IdP that reads this will not attempt them.
/// </remarks>
pplx::task<std::shared_ptr<Iam_config>> getIamScimV2Serviceproviderconfig(
) const;
/// <summary>
/// Returns the people in your organization to your identity provider, in the standard SCIM shape, so an IdP can reconcile its directory against ours.
/// </summary>
/// <remarks>
/// Returns the people in your organization to your identity provider, in the standard SCIM shape, so an IdP can reconcile its directory against ours. Searchable by username or email address, and paged. Reading the whole list takes an administrator; an ordinary person is refused.
/// </remarks>
pplx::task<void> getIamScimV2Users(
) const;
/// <summary>
/// Returns one person in the standard SCIM shape.
/// </summary>
/// <remarks>
/// Returns one person in the standard SCIM shape. An administrator may read anyone in the organization; everyone else may read only themselves.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<void> getIamScimV2UsersByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns your organization&#39;s service accounts — what each is called and when it was created.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s service accounts — what each is called and when it was created. Never their secrets: a key&#39;s secret half exists in a response exactly once, when it is minted. Paginated in memory over the already org-scoped slice — the set per org is small, so a dedicated count query is overkill (v1 service_account.go:296-307).
/// </remarks>
/// <param name="organization">Organization is the organization whose service accounts to list. Required. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="p">P is the 1-indexed page to return. Paging takes both p and pageSize — leave either out, or send something that is not a number, and the whole list comes back. (optional, default to 0L)</param>
/// <param name="pageSize">Size is how many accounts a page holds. (optional, default to 0L)</param>
pplx::task<std::shared_ptr<Iam_Answer>> getIamServiceAccounts(
boost::optional<utility::string_t> organization,
boost::optional<int64_t> p,
boost::optional<int64_t> pageSize
) const;
/// <summary>
/// Returns your organization&#39;s teams, newest first — each a named set of people that roles and permissions are granted to.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s teams, newest first — each a named set of people that roles and permissions are granted to. You see your own organization&#39;s teams and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
pplx::task<std::shared_ptr<Iam_teams_ListOutput>> getIamTeams(
) const;
/// <summary>
/// Returns one team: who is in it.
/// </summary>
/// <remarks>
/// Returns one team: who is in it.
/// </remarks>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Team>> getIamTeamsByName(
utility::string_t name
) const;
/// <summary>
/// Returns a page of the people in an organization, with the total so you can page through the rest.
/// </summary>
/// <remarks>
/// Returns a page of the people in an organization, with the total so you can page through the rest. Passwords, API secrets and MFA material are stripped from every entry. Which organization comes from your credentials, not from the request: you read your own and no one else&#39;s, and a credential whose scope spans tenants reads the tenant it names — or, naming none, every one of them.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="email">Email narrows the page to the accounts carrying one address. Looking a person up by their address is a QUERY over the collection, not an item read: an address is not the natural key, two rows in one org can carry one, and a caller that gets a page SEES both — where a single-item read would have to choose, and choosing is how somebody joins a team under a colleague&#39;s identity. (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="limit"> (optional, default to 0L)</param>
/// <param name="offset"> (optional, default to 0L)</param>
pplx::task<std::shared_ptr<Iam_users_ListOutput>> getIamUsers(
boost::optional<utility::string_t> owner,
boost::optional<utility::string_t> email,
boost::optional<int64_t> limit,
boost::optional<int64_t> offset
) const;
/// <summary>
/// Returns one person in your organization, addressed by their username or by their email address.
/// </summary>
/// <remarks>
/// Returns one person in your organization, addressed by their username or by their email address. Passwords, API secrets and MFA material are stripped from the response. An address that names two accounts names none: the read refuses rather than picking one, and says so instead of reporting \&quot;no such user\&quot;. Handing back an arbitrary one of two rows is how somebody gets added to a team under a colleague&#39;s identity.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="email"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_User>> getIamUsersByOwnerByName(
utility::string_t owner,
utility::string_t name,
boost::optional<utility::string_t> email
) const;
/// <summary>
/// Starts a wallet sign-in: it returns a one-time challenge for the wallet to sign.
/// </summary>
/// <remarks>
/// Starts a wallet sign-in: it returns a one-time challenge for the wallet to sign. The challenge is good once and is tied to the site that asked for it, so a signature collected elsewhere cannot be replayed here.
/// </remarks>
pplx::task<void> getIamWeb3Nonce(
) const;
/// <summary>
/// Starts a passkey sign-in: it returns the challenge the person&#39;s authenticator signs.
/// </summary>
/// <remarks>
/// Starts a passkey sign-in: it returns the challenge the person&#39;s authenticator signs. The account is named in the query, and the challenge is bound to it, so what may answer is decided here — by the server, from the row — and the finish checks the answer against that decision rather than recomputing it.
/// </remarks>
pplx::task<void> getIamWebauthnSigninBegin(
) const;
/// <summary>
/// Starts enrolling a passkey for the signed-in person: it returns the options their browser hands to the authenticator.
/// </summary>
/// <remarks>
/// Starts enrolling a passkey for the signed-in person: it returns the options their browser hands to the authenticator. Passkeys already on the account are EXCLUDED, so a second enrollment on a device that already holds one is refused by the authenticator itself rather than silently producing a duplicate the person cannot tell apart.
/// </remarks>
pplx::task<void> getIamWebauthnSignupBegin(
) const;
/// <summary>
/// Tells you who the current caller is — the lightweight check a page makes on load to decide whether to render signed-in or signed-out.
/// </summary>
/// <remarks>
/// Tells you who the current caller is — the lightweight check a page makes on load to decide whether to render signed-in or signed-out. It answers for a session cookie or a bearer token alike, and says plainly when nobody is signed in rather than failing.
/// </remarks>
pplx::task<void> getIamWhoami(
) const;
/// <summary>
/// Returns your organization&#39;s workspaces, newest first — the scope a team works in, alongside projects rather than instead of them.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s workspaces, newest first — the scope a team works in, alongside projects rather than instead of them. You see your own organization&#39;s workspaces and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_workspaces_ListOutput>> getIamWorkspaces(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns one workspace: what it is called and how it is set up.
/// </summary>
/// <remarks>
/// Returns one workspace: what it is called and how it is set up.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Workspace>> getIamWorkspacesByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Publishes the public keys that verify the tokens issued here — the one URL you point a service at so it can check a token itself, offline, without calling back and without holding any secret of ours.
/// </summary>
/// <remarks>
/// Publishes the public keys that verify the tokens issued here — the one URL you point a service at so it can check a token itself, offline, without calling back and without holding any secret of ours. Keys appear here before they start signing and stay after they stop, so a rotation never leaves a live token unverifiable. Nothing private is ever published.
/// </remarks>
pplx::task<void> getIam_wellKnownJwks(
) const;
/// <summary>
/// Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.
/// </summary>
/// <remarks>
/// Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand. It advertises only what is actually implemented, so a client that reads it cannot ask for a flow that will fail: the authorization-code flow, PKCE with S256, the supported grants, and the signing algorithms whose public keys the JWKS really publishes. The issuer is derived from the host you asked on and is the same value the tokens carry, so a client that pins the issuer never sees it change.
/// </remarks>
pplx::task<void> getIam_wellKnownOauthAuthorizationServer(
) const;
/// <summary>
/// Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.
/// </summary>
/// <remarks>
/// Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand. It advertises only what is actually implemented, so a client that reads it cannot ask for a flow that will fail: the authorization-code flow, PKCE with S256, the supported grants, and the signing algorithms whose public keys the JWKS really publishes. The issuer is derived from the host you asked on and is the same value the tokens carry, so a client that pins the issuer never sees it change.
/// </remarks>
pplx::task<void> getIam_wellKnownOpenidConfiguration(
) const;
/// <summary>
/// Returns one organization: its display, its defaults and the sign-in rules everyone in it inherits.
/// </summary>
/// <remarks>
/// Returns one organization: its display, its defaults and the sign-in rules everyone in it inherits.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_Organization>> getOrganization(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns one provider: what it connects to and how it is configured.
/// </summary>
/// <remarks>
/// Returns one provider: what it connects to and how it is configured. Its credentials come back masked.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_providerResult>> getProvider(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns one person&#39;s session in one application — when it began and which browsers or devices are still carrying it.
/// </summary>
/// <remarks>
/// Returns one person&#39;s session in one application — when it began and which browsers or devices are still carrying it.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="application"></param>
pplx::task<std::shared_ptr<Iam_Session>> getSession(
utility::string_t owner,
utility::string_t name,
utility::string_t application
) const;
/// <summary>
/// Returns one access token: who and what it was issued to, and when it expires.
/// </summary>
/// <remarks>
/// Returns one access token: who and what it was issued to, and when it expires.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_tokenResult>> getToken(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns one passkey or security key: whose it is, what device it lives on, and when it was registered.
/// </summary>
/// <remarks>
/// Returns one passkey or security key: whose it is, what device it lives on, and when it was registered.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<std::shared_ptr<Iam_webauthnCredentialResult>> getWebauthnCredential(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Returns the organizations you can act in, the ones you belong to first and the rest after, newest first, narrowed by an optional query against the name or the display name.
/// </summary>
/// <remarks>
/// Returns the organizations you can act in, the ones you belong to first and the rest after, newest first, narrowed by an optional query against the name or the display name. Platform operators see every organization; everyone else sees their own. Pass the cursor from the previous page to continue; an empty cursor in the answer means there is nothing more. THE SCOPE IS THE HANDLER&#39;S OWN, so it holds at every endpoint. The Guard refuses a bearerless request before this runs, but the MCP server carries a typed op to its handler with no middleware in front of it — a handler that read no principal would answer such a caller with the whole registry. Reading the principal here is what makes the answer the same one over both.
/// </remarks>
/// <param name="xForwardedFor"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="q"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="limit"> (optional, default to 0L)</param>
/// <param name="cursor"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_ListOrganizationsOutput>> listOrganizations(
boost::optional<utility::string_t> xForwardedFor,
boost::optional<utility::string_t> q,
boost::optional<int64_t> limit,
boost::optional<utility::string_t> cursor
) const;
/// <summary>
/// Returns your organization&#39;s providers, newest first — the identity providers your people sign in with, and the senders and connectors your applications go through.
/// </summary>
/// <remarks>
/// Returns your organization&#39;s providers, newest first — the identity providers your people sign in with, and the senders and connectors your applications go through. You see your own organization&#39;s providers and no one else&#39;s; which organization that is comes from your credentials, not from the request.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_listProvidersOut>> listProviders(
boost::optional<utility::string_t> owner
) const;
/// <summary>
/// Returns who is currently signed in to an organization, newest first, and can be narrowed to one person or one application.
/// </summary>
/// <remarks>
/// Returns who is currently signed in to an organization, newest first, and can be narrowed to one person or one application. It is what you read before signing someone out. Which organization comes from your credentials, not from the request: you read your own and no one else&#39;s. A session row names a live account and the applications it is signed in to, so the tenant is decided here rather than taken from the query.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="name"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="application"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_ListSessionsOut>> listSessions(
boost::optional<utility::string_t> owner,
boost::optional<utility::string_t> name,
boost::optional<utility::string_t> application
) const;
/// <summary>
/// Returns the access tokens issued in your organization, newest first, and can be narrowed to one organization.
/// </summary>
/// <remarks>
/// Returns the access tokens issued in your organization, newest first, and can be narrowed to one organization. Use it to see what is currently authorized before revoking anything.
/// </remarks>
/// <param name="owner"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="organization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_listTokensOut>> listTokens(
boost::optional<utility::string_t> owner,
boost::optional<utility::string_t> organization
) const;
/// <summary>
/// Returns the passkeys and security keys registered to one person, newest first — which device each lives on and when it was registered.
/// </summary>
/// <remarks>
/// Returns the passkeys and security keys registered to one person, newest first — which device each lives on and when it was registered. Yours by default. Name somebody else and you get them only if you already administer their account, which is the same authority that governs reading their user record — so this list can never show more people than the surface beside it already does. There is no organization-wide list, by design. Scoping to the ORG would hand an org admin every member&#39;s credential rows in one answer and a SuperAdmin every tenant&#39;s, while a plain member could not read even their own (an unnamed target fails the Guard&#39;s tenant rule). One scope answers both halves cleanly: the answer is a person&#39;s, and the caller is that person unless they say otherwise and may.
/// </remarks>
/// <param name="user"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_listWebauthnCredentialsOut>> listWebauthnCredentials(
boost::optional<utility::string_t> user
) const;
/// <summary>
/// Applies a partial change from your identity provider — one attribute moved, not the whole record resent.
/// </summary>
/// <remarks>
/// Applies a partial change from your identity provider — one attribute moved, not the whole record resent. The change is applied onto the person as they currently are, so everything you did not mention keeps its value, including the parts SCIM does not describe.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<void> patchIamScimV2UsersByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Sets up an account on someone&#39;s behalf — the same onboarding a person gets themselves, driven by one of your own services instead of by them.
/// </summary>
/// <remarks>
/// Sets up an account on someone&#39;s behalf — the same onboarding a person gets themselves, driven by one of your own services instead of by them. It authenticates as your service rather than as a person, which is why the person to provision is named in the request. The setup it performs is identical to self-service onboarding; there is one provisioning path, not two that can drift.
/// </remarks>
pplx::task<void> postIamAdminProvision(
) const;
/// <summary>
/// Registers an application in your organization — one product or site your people sign in to, with its own client credentials, sign-in methods and allowed redirect URIs.
/// </summary>
/// <remarks>
/// Registers an application in your organization — one product or site your people sign in to, with its own client credentials, sign-in methods and allowed redirect URIs. A name already used in the organization is refused rather than overwritten. Exported so the legacy add-application alias reuses this exact path — one create, two spellings.
/// </remarks>
/// <param name="iamApplication"></param>
pplx::task<std::shared_ptr<Iam_Application>> postIamApplications(
std::shared_ptr<Iam_Application> iamApplication
) const;
/// <summary>
/// Steps a platform operator into an organization: it returns their own access token re-scoped to that tenant, so they see what the tenant sees.
/// </summary>
/// <remarks>
/// Steps a platform operator into an organization: it returns their own access token re-scoped to that tenant, so they see what the tenant sees. The token still names the operator — stepping in is not becoming somebody else — and records the organization it was scoped to, so everything done with it is attributed to the person who did it. Only a platform operator may, and the attempt is recorded whether or not it succeeds.
/// </remarks>
/// <param name="iamAssumeBody"></param>
/// <param name="authorization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="xForwardedFor"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> postIamAssume(
std::shared_ptr<Iam_assumeBody> iamAssumeBody,
boost::optional<utility::string_t> authorization,
boost::optional<utility::string_t> xForwardedFor
) const;
/// <summary>
/// Records an audit entry, so activity from your own systems lands in the same trail as everything the Hanzo Cloud records for you.
/// </summary>
/// <remarks>
/// Records an audit entry, so activity from your own systems lands in the same trail as everything the Hanzo Cloud records for you.
/// </remarks>
/// <param name="iamInput"></param>
pplx::task<std::shared_ptr<Iam_AuditLog>> postIamAuditLogs(
std::shared_ptr<Iam_Input> iamInput
) const;
/// <summary>
/// Adds a signing certificate your applications can verify tokens against — the call you make to stage the next one before a rotation.
/// </summary>
/// <remarks>
/// Adds a signing certificate your applications can verify tokens against — the call you make to stage the next one before a rotation. A name already used in your organization is refused. It registers the certificate&#39;s IDENTITY: its name (which is the JWKS &#x60;kid&#x60;), its algorithm, its expiry. Key material does not travel this way and cannot: the private key is not part of the Cert&#39;s JSON, so it is neither served here nor accepted here. It is supplied to the process by the deployment, under the name registered here (internal/keyring). Staging a rotation is therefore two halves — this call names the key, and the deployment provides it.
/// </remarks>
/// <param name="iamCert"></param>
pplx::task<std::shared_ptr<Iam_Cert>> postIamCerts(
std::shared_ptr<Iam_Cert> iamCert
) const;
/// <summary>
/// Takes away a person&#39;s or an application&#39;s right to act in an organization.
/// </summary>
/// <remarks>
/// Takes away a person&#39;s or an application&#39;s right to act in an organization. Their account survives; what ends is their access to that organization. Revoking a membership that is already gone reports that nothing was removed rather than failing, so a retry is safe. It is the mirror of ensure and takes the SAME gate: revoking membership is the org&#39;s authority to give or take, so a SuperAdmin, an admin of the org itself, or an org-admin-capable confidential client. Idempotent through the store — deleting an absent membership reports removed&#x3D;false, never an error — so a retried revoke is safe.
/// </remarks>
pplx::task<void> postIamDeleteMembership(
) const;
/// <summary>
/// Issues an invitation to join your organization — the code or link a new member redeems, with the role they arrive holding and the date it stops working.
/// </summary>
/// <remarks>
/// Issues an invitation to join your organization — the code or link a new member redeems, with the role they arrive holding and the date it stops working. A name already used in the organization is refused.
/// </remarks>
/// <param name="iamInvitationsInput"></param>
pplx::task<std::shared_ptr<Iam_Invitation>> postIamInvitations(
std::shared_ptr<Iam_invitations_Input> iamInvitationsInput
) const;
/// <summary>
/// Issues an API key.
/// </summary>
/// <remarks>
/// Issues an API key. A standard key comes back as a publishable half you may ship in client code and a secret half you must not — the secret is shown once, at creation, and cannot be retrieved afterwards. A publish-scoped key is issued with the publishable half only, so there is no secret to leak. A name already used in your organization is refused rather than reissued, so creating twice never silently invalidates a key that is in production.
/// </remarks>
/// <param name="iamKey"></param>
pplx::task<std::shared_ptr<Iam_Key>> postIamKeys(
std::shared_ptr<Iam_Key> iamKey
) const;
/// <summary>
/// Starts connecting another sign-in identity to the account you are already signed in as.
/// </summary>
/// <remarks>
/// Starts connecting another sign-in identity to the account you are already signed in as. It answers with the provider&#39;s URL for the browser to follow; when the provider returns, that identity is attached and you come back to returnUri. Your account is fixed here, from the credential you are already holding, and is carried server-side for the rest of the round-trip — so nothing that happens at the provider can point the link at somebody else.
/// </remarks>
pplx::task<void> postIamLink(
) const;
/// <summary>
/// Signs a person in with the credential they typed, and — when the request is part of an OAuth flow — hands back the one-time code that finishes it.
/// </summary>
/// <remarks>
/// Signs a person in with the credential they typed, and — when the request is part of an OAuth flow — hands back the one-time code that finishes it. A second factor, if the account has one, is asked for and required here. The password is compared against a stored one-way hash and is never logged, echoed or stored as typed.
/// </remarks>
pplx::task<void> postIamLogin(
) const;
/// <summary>
/// Lets a person or an application act in an organization.
/// </summary>
/// <remarks>
/// Lets a person or an application act in an organization. It is the grant behind \&quot;add someone to the team\&quot;, and it is safe to repeat — granting a membership that already exists changes nothing. Granting membership IS the org&#39;s authority to give, so it takes the same gate a write to that org&#39;s own registry row takes: a SuperAdmin, an admin of the org itself, or an org-admin-capable confidential client. One rule, one place (internal/authz).
/// </remarks>
pplx::task<void> postIamMemberships(
) const;
/// <summary>
/// Picks which second factor an account is asked for first when it has more than one.
/// </summary>
/// <remarks>
/// Picks which second factor an account is asked for first when it has more than one. Only a factor the account actually holds: storing an unheld one told the login gate \&quot;MFA is on\&quot; — factor.Enabled reads that column — while leaving it nothing to ask for, so the sign-in required the password alone.
/// </remarks>
pplx::task<void> postIamMfaPreferred(
) const;
/// <summary>
/// Finishes the enrolment: from here the account&#39;s sign-ins ask for this factor.
/// </summary>
/// <remarks>
/// Finishes the enrolment: from here the account&#39;s sign-ins ask for this factor. It requires the proof initiate handed out — a passcode from the authenticator, or the code that was sent — and verifies it BEFORE writing anything. Verifying BEFORE writing is what keeps a client that never completed the proof — a skipped verify step, a QR scanned into the wrong app, a bug — from switching on a factor no code can satisfy. That would lock the account out with no self-service way back: the gate holds the sign-in before minting, so the person could not obtain the bearer that disable requires. The recovery codes are minted here and returned ONCE, on the first factor the account adds. Answering with them is the way back in when no factor can be produced, so they are the same value the row&#39;s digests were made from — by construction, not by a client echoing them back.
/// </remarks>
pplx::task<void> postIamMfaSetupEnable(
) const;
/// <summary>
/// Starts enrolling a factor and hands over whatever the person needs to prove they hold it: app a fresh secret and the otpauth:// URL to render as a QR code sms a code texted to the number on the account email a code mailed to the address on the account Nothing is switched on yet, so abandoning this step leaves the account exactly as it was.
/// </summary>
/// <remarks>
/// Starts enrolling a factor and hands over whatever the person needs to prove they hold it: app a fresh secret and the otpauth:// URL to render as a QR code sms a code texted to the number on the account email a code mailed to the address on the account Nothing is switched on yet, so abandoning this step leaves the account exactly as it was. Response: {status:\&quot;ok\&quot;, data:{mfaType, secret, url}} — secret and url only for the authenticator.
/// </remarks>
pplx::task<void> postIamMfaSetupInitiate(
) const;
/// <summary>
/// Starts a sign-in — the address you send a browser to, and the beginning of every OAuth and OpenID Connect flow.
/// </summary>
/// <remarks>
/// Starts a sign-in — the address you send a browser to, and the beginning of every OAuth and OpenID Connect flow. If the person is ALREADY signed in here, it does not ask them again: it returns them to the application with a one-time code and they never see this page. Otherwise it shows the right way to sign in for the application they are signing in to, or hands off to another identity provider if that is what they pick. A client can say what it wants with &#x60;prompt&#x60;: &#x60;none&#x60; means answer without any screen at all — with the code if a session exists, with an error if not, but never with a page; &#x60;login&#x60; means ask for the password again even if a session exists; &#x60;select_account&#x60; means let the person choose which identity to use. It returns only to an address the application has registered. That check happens before anything else, so a request naming an unregistered address is refused where the person can see it rather than being bounced onwards.
/// </remarks>
pplx::task<void> postIamOauthAuthorize(
) const;
/// <summary>
/// Starts a sign-in on a device with no browser and no keyboard — a TV, a CLI, a headless box.
/// </summary>
/// <remarks>
/// Starts a sign-in on a device with no browser and no keyboard — a TV, a CLI, a headless box. It returns a short code to show the person and the address to send them to on a phone or laptop. Nothing is granted until a human approves it there; until then the code is just a pending request.
/// </remarks>
pplx::task<void> postIamOauthDevice(
) const;
/// <summary>
/// Answers \&quot;what am I approving?\&quot; for a pending device code.
/// </summary>
/// <remarks>
/// Answers \&quot;what am I approving?\&quot; for a pending device code. The approval page exists to tell a human WHICH application they are authorizing; a page that names any other one defeats the control it implements. The client is a property of the CODE, not of the page or of whatever app the browser happens to be signed in to, so it is read from the code&#39;s row here and nowhere else. Requires a signed-in session, and answers with the same ONE opaque refusal approveDevice uses. That is deliberate: the user_code is only 40 bits and is the one secret in this flow, so an unauthenticated lookup — or one that distinguished unknown from expired from already-approved — would be an oracle for hunting live codes. Gated and opaque, it reveals strictly less than the approval the same caller could already attempt.
/// </remarks>
pplx::task<void> postIamOauthDeviceInfo(
) const;
/// <summary>
/// Completes a sign-in that came in through another identity provider and still owes a second factor.
/// </summary>
/// <remarks>
/// Completes a sign-in that came in through another identity provider and still owes a second factor. The person supplies the factor here and the login finishes. The account is fixed when the challenge is issued, not by the request, so no one can redirect a half-finished login onto somebody else&#39;s account. A wrong factor uses the challenge up: retrying means starting the sign-in again, the same as a mistyped password.
/// </remarks>
pplx::task<void> postIamOauthFederationMfa(
) const;
/// <summary>
/// Answers whether an access token is still good, and what it is good for — the check a resource server of yours makes before honouring a token it did not mint.
/// </summary>
/// <remarks>
/// Answers whether an access token is still good, and what it is good for — the check a resource server of yours makes before honouring a token it did not mint. A token counts as active only if it verifies AND has not been revoked, so a revoked token reads as dead here immediately rather than until it expires. A token that is unknown, expired or revoked answers simply that it is not active, and nothing more — the endpoint is not a way to learn about tokens you were not given.
/// </remarks>
pplx::task<void> postIamOauthIntrospect(
) const;
/// <summary>
/// Ends a sign-in and sends the browser somewhere sensible.
/// </summary>
/// <remarks>
/// Ends a sign-in and sends the browser somewhere sensible. Accepts GET or POST, so it works as a plain link. It ACTUALLY signs you out — worth stating, because a logout that computes a redirect and answers {\&quot;status\&quot;:\&quot;ok\&quot;} while ending no session and revoking no token is worse than none: the person on the shared machine believes it worked. Three things happen here, in this order: 1. The browser session dies — sid revoked server-side AND the cookie expired (sessions.Clear). Server-side revocation is the load-bearing half: a copy of the cookie taken before logout must not still resolve. 2. The relying party&#39;s tokens are revoked when an id_token_hint names it, so the refresh token cannot mint a fresh access token after the human left. Revocation state is authoritative — a JWT&#39;s &#x60;exp&#x60; still reads valid for days, so expiry is necessary but never sufficient. 3. Only then is a redirect considered, and only to a REGISTERED uri. The open-redirect guard is unchanged: a redirect happens only when a VERIFIED id_token_hint identifies the application and that application has registered the target. Anything else refuses to redirect — nobody can turn your logout link into a redirect to a site of their choosing.
/// </remarks>
pplx::task<void> postIamOauthLogout(
) const;
/// <summary>
/// Retires a token before it expires — what you call when someone signs out or a credential may have leaked.
/// </summary>
/// <remarks>
/// Retires a token before it expires — what you call when someone signs out or a credential may have leaked. Revoking an access token kills that token. Revoking a REFRESH token kills the whole chain it belongs to, so no further access tokens can be minted from it and every token already minted from it dies with it. A token that is not yours, or that never existed, answers success and does nothing — so the endpoint cannot be used to discover which tokens are real. PUBLIC clients revoke too, and must: sign-out is the only control a long-lived refresh token has. A native app or CLI is a public PKCE client and holds no secret, so requiring one here would leave signing out as a local delete — forgetting a credential that stays spendable for the rest of its lifetime. Widening authentication does not widen authority. The caller must still POSSESS the token — and possession already permits USE, of which revocation is the strict opposite — and the row must belong to the client that presents it, so a public client_id buys the ability to destroy exactly what its holder could otherwise spend. RFC 6749 §3.2.1 is the same reading: a client with no credentials identifies itself with client_id.
/// </remarks>
pplx::task<void> postIamOauthRevoke(
) const;
/// <summary>
/// Exchanges what your application is holding for the tokens it needs — the one-time code from a finished sign-in, a refresh token, or your own client credentials when the caller is a program rather than a person.
/// </summary>
/// <remarks>
/// Exchanges what your application is holding for the tokens it needs — the one-time code from a finished sign-in, a refresh token, or your own client credentials when the caller is a program rather than a person. A refresh returns a NEW refresh token and retires the one you sent. If a retired one is ever presented again the whole chain is revoked, on the assumption that a token which came back from the dead was copied — so a stolen refresh token buys an attacker one use and costs them the session. Responses are never cached, by any hop.
/// </remarks>
pplx::task<void> postIamOauthToken(
) const;
/// <summary>
/// Returns the profile claims for whoever the access token belongs to — the standard OpenID Connect way to find out who is calling you without your application storing anything itself.
/// </summary>
/// <remarks>
/// Returns the profile claims for whoever the access token belongs to — the standard OpenID Connect way to find out who is calling you without your application storing anything itself. The token must still be live: revoke it and this stops answering.
/// </remarks>
pplx::task<void> postIamOauthUserinfo(
) const;
/// <summary>
/// Finishes setting up the account of whoever is calling — it creates their organization if they have none and puts them in it, so a person who has just signed up lands somewhere they can work.
/// </summary>
/// <remarks>
/// Finishes setting up the account of whoever is calling — it creates their organization if they have none and puts them in it, so a person who has just signed up lands somewhere they can work. It always acts on the caller and never on somebody named in the request, so there is no way to onboard another person&#39;s account through it.
/// </remarks>
pplx::task<void> postIamOnboard(
) const;
/// <summary>
/// Grants a permission — the call that gives a person or a role the ability to do something.
/// </summary>
/// <remarks>
/// Grants a permission — the call that gives a person or a role the ability to do something. Adding refuses to overwrite a grant that already exists, so widening an existing one is an update, never an accident.
/// </remarks>
/// <param name="iamPermission"></param>
pplx::task<std::shared_ptr<Iam_Permission>> postIamPermissions(
std::shared_ptr<Iam_Permission> iamPermission
) const;
/// <summary>
/// Saves the calling person&#39;s own settings and returns the full set afterwards.
/// </summary>
/// <remarks>
/// Saves the calling person&#39;s own settings and returns the full set afterwards. Send only the settings you are changing — the rest are kept, so two screens can save at once without one undoing the other.
/// </remarks>
pplx::task<void> postIamPreferences(
) const;
/// <summary>
/// Makes a project inside your organization — the scope people pick between when their work is separated by product or client rather than by team.
/// </summary>
/// <remarks>
/// Makes a project inside your organization — the scope people pick between when their work is separated by product or client rather than by team. A name already used in the organization is refused.
/// </remarks>
/// <param name="iamProjectsInput"></param>
pplx::task<std::shared_ptr<Iam_Project>> postIamProjects(
std::shared_ptr<Iam_projects_Input> iamProjectsInput
) const;
/// <summary>
/// Signs a container client in to your registry.
/// </summary>
/// <remarks>
/// Signs a container client in to your registry. &#x60;docker login&#x60;, and every build tool that pushes or pulls images, lands here: it exchanges the credential for a short-lived token scoped to exactly the repositories that credential may touch. Both of the shapes container tooling uses are accepted, so the same login works whichever client your pipeline runs.
/// </remarks>
pplx::task<void> postIamRegistryToken(
) const;
/// <summary>
/// Steps a platform operator back out: it returns their own access token with no organization assumed, which is the credential they had before they stepped in.
/// </summary>
/// <remarks>
/// Steps a platform operator back out: it returns their own access token with no organization assumed, which is the credential they had before they stepped in. Recorded like the step in.
/// </remarks>
/// <param name="iamAssumeBody"></param>
/// <param name="authorization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="xForwardedFor"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> postIamRelease(
std::shared_ptr<Iam_assumeBody> iamAssumeBody,
boost::optional<utility::string_t> authorization,
boost::optional<utility::string_t> xForwardedFor
) const;
/// <summary>
/// Makes a role — a named group of people that permissions are granted to.
/// </summary>
/// <remarks>
/// Makes a role — a named group of people that permissions are granted to. Granting to a role rather than to each person is what keeps access correct as your team changes: add someone to the role and they inherit everything it can do. A name already used in your organization is refused.
/// </remarks>
/// <param name="iamRolesInput"></param>
pplx::task<std::shared_ptr<Iam_Role>> postIamRoles(
std::shared_ptr<Iam_roles_Input> iamRolesInput
) const;
/// <summary>
/// Provisions a person from your identity provider — how a new hire gets an account here automatically when they are added over there.
/// </summary>
/// <remarks>
/// Provisions a person from your identity provider — how a new hire gets an account here automatically when they are added over there. Takes an administrator. Making someone an administrator takes more than that, so an IdP integration cannot escalate anyone by setting a flag.
/// </remarks>
pplx::task<void> postIamScimV2Users(
) const;
/// <summary>
/// Makes a service account — an identity for a program rather than a person, for a script, a bot or a deployment that has to authenticate on its own.
/// </summary>
/// <remarks>
/// Makes a service account — an identity for a program rather than a person, for a script, a bot or a deployment that has to authenticate on its own. It comes back with its first key, and the secret half is shown ONCE, here. There is no way to read it again; if you lose it, rotate.
/// </remarks>
pplx::task<void> postIamServiceAccounts(
) const;
/// <summary>
/// Serves POST /v1/iam/service-accounts/:name/keys: mint a fresh key, invalidating the prior one, and return the new raw secret exactly once.
/// </summary>
/// <remarks>
/// Serves POST /v1/iam/service-accounts/:name/keys: mint a fresh key, invalidating the prior one, and return the new raw secret exactly once.
/// </remarks>
/// <param name="name"></param>
pplx::task<void> postIamServiceAccountsByNameKeys(
utility::string_t name
) const;
/// <summary>
/// Completes a sign-in: it exchanges the one-time code your application was handed at the end of the login flow for a live session, and returns the signed-in account.
/// </summary>
/// <remarks>
/// Completes a sign-in: it exchanges the one-time code your application was handed at the end of the login flow for a live session, and returns the signed-in account. The code works once. This is the call that turns a finished login into something your application can act on.
/// </remarks>
pplx::task<void> postIamSignin(
) const;
/// <summary>
/// Creates an account from the sign-up form and applies the application&#39;s own sign-up rules — whether self-service registration is open at all, and which fields it requires.
/// </summary>
/// <remarks>
/// Creates an account from the sign-up form and applies the application&#39;s own sign-up rules — whether self-service registration is open at all, and which fields it requires. The password is hashed before it is stored and is never returned.
/// </remarks>
pplx::task<void> postIamSignup(
) const;
/// <summary>
/// Makes a team — a named set of people that roles and permissions grant to.
/// </summary>
/// <remarks>
/// Makes a team — a named set of people that roles and permissions grant to. Granting to a team rather than to each person keeps access correct as people come and go: add someone and they inherit what the team can do. A name already used in your organization is refused.
/// </remarks>
/// <param name="iamTeamsInput"></param>
pplx::task<std::shared_ptr<Iam_Team>> postIamTeams(
std::shared_ptr<Iam_teams_Input> iamTeamsInput
) const;
/// <summary>
/// Mints an access token for the &#x60;?id&#x3D;&lt;owner&gt;/&lt;name&gt;&#x60; target user (optional &#x60;?aud&#x3D;&#x60; resource, RFC 8707), issued by the authenticated + allow-listed confidential client.
/// </summary>
/// <remarks>
/// Mints an access token for the &#x60;?id&#x3D;&lt;owner&gt;/&lt;name&gt;&#x60; target user (optional &#x60;?aud&#x3D;&#x60; resource, RFC 8707), issued by the authenticated + allow-listed confidential client. The token&#39;s subject + owner are the TARGET USER&#39;s, so a resource server scopes on the validated owner claim to the user&#39;s tenant — indistinguishable from a token the user obtained directly. Response is the camelCase &#x60;{accessToken, expiresIn}&#x60; body identity.ts consumes. Equivalent to the RFC 8693 token-exchange grant, minus the subject_token proof (the console has the user&#39;s id, not a token) — the reason this compat shim exists.
/// </remarks>
pplx::task<void> postIamTokensIssue(
) const;
/// <summary>
/// Disconnects one sign-in identity from an account, so that provider can no longer be used to sign in as that person.
/// </summary>
/// <remarks>
/// Disconnects one sign-in identity from an account, so that provider can no longer be used to sign in as that person. Their account and every other way they sign in are untouched. Two principals may do it, and only two: the account holder itself, and a SuperAdmin (a member of the reserved admin org, the one predicate). An ORG ADMIN deliberately may NOT — unlinking is not tenant administration, it is unpicking someone&#39;s own sign-in method, so the generic org-admin rule is the wrong answer here. A holder unlinking itself must also be permitted by the application — the provider link&#39;s CanUnlink flag — so an organization that mandates federated sign-in cannot have its users strand themselves. A SuperAdmin is not bound by that flag; it is the platform&#39;s own recovery path. Fail-closed throughout.
/// </remarks>
pplx::task<void> postIamUnlink(
) const;
/// <summary>
/// Adds a person to your organization.
/// </summary>
/// <remarks>
/// Adds a person to your organization. Send a password and it becomes the one they sign in with; it is hashed before it is stored and never comes back in any response. The username is checked against the same rule every account in the Hanzo Cloud is held to, whichever way it was created — this call, password signup, a social sign-in, or SCIM — so a name accepted here works everywhere. A name already taken in your organization is refused rather than overwritten.
/// </remarks>
/// <param name="iamCreateInput"></param>
pplx::task<std::shared_ptr<Iam_User>> postIamUsers(
std::shared_ptr<Iam_CreateInput> iamCreateInput
) const;
/// <summary>
/// (re)generates the target user&#39;s key of the requested TYPE and returns it once, over the shared authorizeMinter + mintTarget seam.
/// </summary>
/// <remarks>
/// (re)generates the target user&#39;s key of the requested TYPE and returns it once, over the shared authorizeMinter + mintTarget seam. &#x60;?type&#x3D;secret&#x60; (the default) yields the confidential sk-; &#x60;?type&#x3D;publishable&#x60; yields the pk- that is safe to ship in client JS and resolves to an org, never a principal. It writes the schema.Key row that the resolvers actually read. schema.User.AccessKey is not a credential and nothing resolves it, so a key stamped there would authenticate nobody.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<void> postIamUsersByOwnerByNameKeys(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Validates the request and asks otp to get a code to the person.
/// </summary>
/// <remarks>
/// Validates the request and asks otp to get a code to the person. The request fields are read via fiber&#39;s FormValue — the escape hatch zip exposes for form bodies (multipart or urlencoded) — since the typed JSON Bind does not apply here. v1 also accepts countryCode/method/checkUser/captchaType; iam ignores them (the captcha/forget/MFA flows those drive are not ported), and CAPTCHA verification is likewise not enforced — iam models no captcha provider — so the code is issued once the destination and application validate.
/// </remarks>
pplx::task<void> postIamVerificationCodes(
) const;
/// <summary>
/// Completes a wallet sign-in: it verifies the signed challenge and, if it holds, signs the wallet&#39;s owner in.
/// </summary>
/// <remarks>
/// Completes a wallet sign-in: it verifies the signed challenge and, if it holds, signs the wallet&#39;s owner in. This IS the login — it answers exactly as a password sign-in does, so the rest of your flow does not branch on how somebody arrived.
/// </remarks>
pplx::task<void> postIamWeb3Verify(
) const;
/// <summary>
/// Verifies the signed challenge and signs the person in.
/// </summary>
/// <remarks>
/// Verifies the signed challenge and signs the person in. It answers exactly as a password sign-in does — the same envelope, through the same grant — so nothing downstream branches on how somebody arrived.
/// </remarks>
pplx::task<void> postIamWebauthnSigninFinish(
) const;
/// <summary>
/// Verifies the newly created passkey and stores it, so the person can sign in with their device from then on.
/// </summary>
/// <remarks>
/// Verifies the newly created passkey and stores it, so the person can sign in with their device from then on.
/// </remarks>
pplx::task<void> postIamWebauthnSignupFinish(
) const;
/// <summary>
/// Makes a workspace inside your organization — the scope a team works in, alongside projects rather than instead of them.
/// </summary>
/// <remarks>
/// Makes a workspace inside your organization — the scope a team works in, alongside projects rather than instead of them. A name already used in the organization is refused.
/// </remarks>
/// <param name="iamWorkspacesInput"></param>
pplx::task<std::shared_ptr<Iam_Workspace>> postIamWorkspaces(
std::shared_ptr<Iam_workspaces_Input> iamWorkspacesInput
) const;
/// <summary>
/// Saves the calling person&#39;s own profile — the name they are shown by, their picture, a line about themselves and a link.
/// </summary>
/// <remarks>
/// Saves the calling person&#39;s own profile — the name they are shown by, their picture, a line about themselves and a link. Only their own: the request names nobody, so it cannot reach another account. Send only what you are changing; a field you leave out keeps the value it had, and a field you send empty is cleared. A picture is an https link or an inline image up to 96 KiB, the same value an organization&#39;s mark is (schema.AvatarRef) — one rule for how a subject appears, whether the subject is a person or an organization.
/// </remarks>
/// <param name="iamAccountBody"></param>
/// <param name="cookie"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="authorization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> putIamAccount(
std::shared_ptr<Iam_accountBody> iamAccountBody,
boost::optional<utility::string_t> cookie,
boost::optional<utility::string_t> authorization
) const;
/// <summary>
/// Changes an application&#39;s display, its sign-in methods and the redirect URIs it may return to — the call that makes login work from a new host.
/// </summary>
/// <remarks>
/// Changes an application&#39;s display, its sign-in methods and the redirect URIs it may return to — the call that makes login work from a new host. Which organization it belongs to and what it is named are fixed when it is created and are not editable here. Exported so the legacy update-application alias reuses this exact path — one update, two spellings.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamApplication"></param>
pplx::task<std::shared_ptr<Iam_Application>> putIamApplicationsByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Application> iamApplication
) const;
/// <summary>
/// Corrects an audit entry.
/// </summary>
/// <remarks>
/// Corrects an audit entry. The trail is append-only in normal operation and nothing in the Hanzo Cloud rewrites it — this exists for an administrator to correct an entry their own systems recorded wrongly.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamInput"></param>
pplx::task<std::shared_ptr<Iam_AuditLog>> putIamAuditLogsByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Input> iamInput
) const;
/// <summary>
/// Changes a signing certificate&#39;s settings.
/// </summary>
/// <remarks>
/// Changes a signing certificate&#39;s settings. What it is called does not change, and neither does when it was added. A PUT here is a METADATA edit — display name, expiry, provider. It overlays only the fields the request actually SET onto the loaded row: a field the JSON omits (or leaves at its zero value) keeps what the row holds, rather than blanking it. That is load-bearing, not a nicety. A read serves the public Certificate (Mask hides only PrivateKey and AccessSecret), so a client that reads a cert, changes one field, and writes it back sends the masked halves empty and every other field it did not touch at its zero value — and the old full-struct overlay wrote all of those blanks back. Blanking CryptoAlgorithm alone drops the cert from the JWKS (oidc.Publishes turns false), so every token under its &#x60;kid&#x60; stops verifying; blanking Provider/Account/ExpireTime breaks ACME renewal and expiry — all from a request that only meant to rename it. Absent-or-zero means \&quot;unchanged\&quot;, so the deployment (key) and a rotation (cert) remain the only way key or published material changes; the metadata API cannot clear it. The overlay is generic — it copies every set field, so a field nobody has added yet is carried without a line here — and leaves three things the request may not move: the bound Model (id, createdAt, key, snapshot), the natural key (owner/name address the row, they do not mutate it), and the creation stamp.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamCert"></param>
pplx::task<std::shared_ptr<Iam_Cert>> putIamCertsByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Cert> iamCert
) const;
/// <summary>
/// Records the calling person&#39;s privacy and communication choices.
/// </summary>
/// <remarks>
/// Records the calling person&#39;s privacy and communication choices. Only their own — there is no way to set consent for somebody else. Send only the answers you are changing. A question you leave out keeps the answer it already had, so a screen that saves one switch never revokes the other, and two screens saving at once do not undo each other. An answer this version does not recognize is refused here rather than stored, so nothing is ever persisted for a later reader to have to interpret.
/// </remarks>
pplx::task<void> putIamConsent(
) const;
/// <summary>
/// Changes an invitation&#39;s terms — the role it grants, how many may redeem it, or when it expires.
/// </summary>
/// <remarks>
/// Changes an invitation&#39;s terms — the role it grants, how many may redeem it, or when it expires. What it is called does not change.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamInvitationsInput"></param>
pplx::task<std::shared_ptr<Iam_Invitation>> putIamInvitationsByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_invitations_Input> iamInvitationsInput
) const;
/// <summary>
/// Changes what a key is called or what it may reach.
/// </summary>
/// <remarks>
/// Changes what a key is called or what it may reach. The credential itself is not reissued — the key in your deployment keeps working.
/// </remarks>
/// <param name="owner">Owner is the tenant that holds the key; Name is unique within Owner.</param>
/// <param name="name"></param>
/// <param name="iamKey"></param>
pplx::task<std::shared_ptr<Iam_Key>> putIamKeysByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Key> iamKey
) const;
/// <summary>
/// Replaces the calling person&#39;s password.
/// </summary>
/// <remarks>
/// Replaces the calling person&#39;s password. Only their own — there is no shape of this request that writes somebody else&#39;s. Prove who you are with the password you are replacing, or — when you cannot sign in at all — with a code sent to the address the account already holds. Exactly one of the two: a request carrying both proves nothing more than either, and answering it would mean deciding which one mattered. A reset also clears the account lockout, in the SAME transaction as the digest. Replacing a credential retires the run of guesses against the old one, and without this a person who reset a forgotten password was still refused for up to fifteen more minutes — with the brand-new password they had just chosen.
/// </remarks>
/// <param name="iamPasswordBody"></param>
/// <param name="cookie"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
/// <param name="authorization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_Answer>> putIamPassword(
std::shared_ptr<Iam_passwordBody> iamPasswordBody,
boost::optional<utility::string_t> cookie,
boost::optional<utility::string_t> authorization
) const;
/// <summary>
/// Changes who a permission grants to, what it allows, or the resources it covers.
/// </summary>
/// <remarks>
/// Changes who a permission grants to, what it allows, or the resources it covers. Access changes as soon as the write lands. What the permission is called does not change, and neither does when it was created.
/// </remarks>
/// <param name="owner">Identity — the (owner, name) natural key.</param>
/// <param name="name"></param>
/// <param name="iamPermission"></param>
pplx::task<std::shared_ptr<Iam_Permission>> putIamPermissionsByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Permission> iamPermission
) const;
/// <summary>
/// Changes a project&#39;s settings.
/// </summary>
/// <remarks>
/// Changes a project&#39;s settings. What it is called does not change, and neither does when it was created.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamProjectsInput"></param>
pplx::task<std::shared_ptr<Iam_Project>> putIamProjectsByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_projects_Input> iamProjectsInput
) const;
/// <summary>
/// Changes who is in a role, or which roles it includes.
/// </summary>
/// <remarks>
/// Changes who is in a role, or which roles it includes. Access changes for everyone in it as soon as the write lands. What the role is called does not change, and neither does when it was created.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamRolesInput"></param>
pplx::task<std::shared_ptr<Iam_Role>> putIamRolesByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_roles_Input> iamRolesInput
) const;
/// <summary>
/// Overwrites a person&#39;s SCIM attributes with what your identity provider sends — how a change made there lands here.
/// </summary>
/// <remarks>
/// Overwrites a person&#39;s SCIM attributes with what your identity provider sends — how a change made there lands here. Only the attributes SCIM describes are replaced. Anything the standard does not cover — their multi-factor enrolment above all — survives untouched, so a routine sync from your IdP can never quietly strip someone&#39;s second factor or bring a deleted account back.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
pplx::task<void> putIamScimV2UsersByOwnerByName(
utility::string_t owner,
utility::string_t name
) const;
/// <summary>
/// Changes who is in a team.
/// </summary>
/// <remarks>
/// Changes who is in a team. Access changes for everyone in it as soon as the write lands. The name and the created stamp do not change.
/// </remarks>
/// <param name="name">Name addresses the team on update and names it on create; every other field is content and binds from the BODY, never the URL.</param>
/// <param name="iamTeamsInput"></param>
pplx::task<std::shared_ptr<Iam_Team>> putIamTeamsByName(
utility::string_t name,
std::shared_ptr<Iam_teams_Input> iamTeamsInput
) const;
/// <summary>
/// Changes a person&#39;s profile, their roles, or the credentials they sign in with.
/// </summary>
/// <remarks>
/// Changes a person&#39;s profile, their roles, or the credentials they sign in with. Send a password to reset it; leave it out and their current one keeps working. Who they are does not change: their organization, username and the identifier their existing sessions are keyed on all survive the write, so an update never signs anyone out.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamUpdateInput"></param>
pplx::task<std::shared_ptr<Iam_User>> putIamUsersByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_UpdateInput> iamUpdateInput
) const;
/// <summary>
/// Changes a workspace&#39;s settings.
/// </summary>
/// <remarks>
/// Changes a workspace&#39;s settings. What it is called does not change, and neither does when it was created.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamWorkspacesInput"></param>
pplx::task<std::shared_ptr<Iam_Workspace>> putIamWorkspacesByOwnerByName(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_workspaces_Input> iamWorkspacesInput
) const;
/// <summary>
/// Changes how an organization appears across Hanzo: the square mark beside its name, as an uploaded image or as a single emoji.
/// </summary>
/// <remarks>
/// Changes how an organization appears across Hanzo: the square mark beside its name, as an uploaded image or as a single emoji. Sending an image clears the emoji and sending an emoji clears the image — an organization has one mark, not a preference order — and sending neither clears both, which is how it goes back to being drawn as its initial. An image is an https link or the bytes inline as a data URL, up to 96 KiB. Anyone who administers the organization may set this; it is not reserved to the platform. It writes the two fields onto the stored row and touches nothing else, which update cannot do: update replaces the whole record, and a record read back first arrives masked, so a read-modify-write through it would persist the mask over the organization&#39;s own credential settings.
/// </remarks>
/// <param name="iamSetAvatarInput"></param>
pplx::task<std::shared_ptr<Iam_Organization>> setOrganizationAvatar(
std::shared_ptr<Iam_SetAvatarInput> iamSetAvatarInput
) const;
/// <summary>
/// Changes how an organization reads: its display name, its website and its favicon.
/// </summary>
/// <remarks>
/// Changes how an organization reads: its display name, its website and its favicon. IT EXISTS FOR THE REASON SetAvatar DOES, and the reason is worth stating because the obvious alternative is a trap. Update REPLACES the whole record, so a caller that wants to change one field has to send every other field back — and a record read back first arrives MASKED, so the read half of that read-modify-write hands you \&quot;***\&quot; for the master password and the salt, and the write half stores it. Renaming an organization through Update therefore costs it its credential settings; sending only the new name costs it everything else. Neither is a rename. So this writes the fields it names and touches nothing else. A nil pointer is not sent and not changed; an empty string is sent and clears the field.
/// </remarks>
/// <param name="iamSetProfileInput"></param>
pplx::task<std::shared_ptr<Iam_Organization>> setOrganizationProfile(
std::shared_ptr<Iam_SetProfileInput> iamSetProfileInput
) const;
/// <summary>
/// Changes an organization&#39;s display, its defaults and the sign-in rules everyone in it inherits.
/// </summary>
/// <remarks>
/// Changes an organization&#39;s display, its defaults and the sign-in rules everyone in it inherits. Which organization it is does not change, and neither does when it was created.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamUpdateOrganizationInput"></param>
pplx::task<std::shared_ptr<Iam_Organization>> updateOrganization(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_UpdateOrganizationInput> iamUpdateOrganizationInput
) const;
/// <summary>
/// Changes a provider&#39;s settings or rotates the credentials it holds.
/// </summary>
/// <remarks>
/// Changes a provider&#39;s settings or rotates the credentials it holds. The change takes effect on the next sign-in through it — sessions already issued are unaffected. A provider that is not there answers \&quot;nothing changed\&quot; rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamProvider"></param>
pplx::task<std::shared_ptr<Iam_mutationResult>> updateProvider(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Provider> iamProvider
) const;
/// <summary>
/// Names the browsers a session keeps — signing out the ones you leave off while the session itself stays live.
/// </summary>
/// <remarks>
/// Names the browsers a session keeps — signing out the ones you leave off while the session itself stays live. A session that does not exist is reported as missing rather than created.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="application"></param>
/// <param name="iamUpdateSessionIn"></param>
pplx::task<std::shared_ptr<Iam_Session>> updateSession(
utility::string_t owner,
utility::string_t name,
utility::string_t application,
std::shared_ptr<Iam_UpdateSessionIn> iamUpdateSessionIn
) const;
/// <summary>
/// Changes an access token&#39;s scope or expiry.
/// </summary>
/// <remarks>
/// Changes an access token&#39;s scope or expiry. A token that is not there answers \&quot;nothing changed\&quot; rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamToken"></param>
pplx::task<std::shared_ptr<Iam_tokenMutation>> updateToken(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_Token> iamToken
) const;
/// <summary>
/// Renames a registered passkey or security key, so a person can tell their devices apart.
/// </summary>
/// <remarks>
/// Renames a registered passkey or security key, so a person can tell their devices apart. A credential that is not there answers \&quot;nothing changed\&quot; rather than an error, so the call is safe to repeat.
/// </remarks>
/// <param name="owner"></param>
/// <param name="name"></param>
/// <param name="iamWebauthnCredential"></param>
pplx::task<std::shared_ptr<Iam_webauthnCredentialMutationResult>> updateWebauthnCredential(
utility::string_t owner,
utility::string_t name,
std::shared_ptr<Iam_WebauthnCredential> iamWebauthnCredential
) const;
/// <summary>
/// Creates an application or updates it in place, so a deployment can declare the applications it needs and run the same declaration on every environment and on every redeploy.
/// </summary>
/// <remarks>
/// Creates an application or updates it in place, so a deployment can declare the applications it needs and run the same declaration on every environment and on every redeploy. It says which of the two it did. Leave the client secret out and the existing one is kept — so re-running your deployment does not rotate a credential your running services are holding.
/// </remarks>
/// <param name="iamRegistration"></param>
/// <param name="authorization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_reply>> upsertApplication(
std::shared_ptr<Iam_registration> iamRegistration,
boost::optional<utility::string_t> authorization
) const;
/// <summary>
/// Creates a person or updates them in place, so a deployment can declare the accounts it needs and re-run that declaration safely.
/// </summary>
/// <remarks>
/// Creates a person or updates them in place, so a deployment can declare the accounts it needs and re-run that declaration safely. It DESCRIBES an account it meets and GRANTS only to one it creates: org-admin is never raised on a row that already exists, and a machine identity is answered by name rather than adopted. Both are properties of the update itself, so a steady-state reconcile — which changes neither — is unaffected. Passwords are hashed before they are stored. Leave the password out and their current one is kept, so a redeploy never locks somebody out; send the same one again and it is kept too, so a steady-state re-run is not a rotation.
/// </remarks>
/// <param name="iamPerson"></param>
/// <param name="authorization"> (optional, default to utility::conversions::to_string_t(&quot;&quot;))</param>
pplx::task<std::shared_ptr<Iam_reply>> upsertUser(
std::shared_ptr<Iam_person> iamPerson,
boost::optional<utility::string_t> authorization
) const;
protected:
std::shared_ptr<const ApiClient> m_ApiClient;
};
}
}
#endif /* HANZO_API_IamApi_H_ */