public_api.fetcher.ts

/* @generated by `@turnkey/fetchers`. DO NOT EDIT BY HAND */

import {
  request,
  signedRequest,
  TurnkeyCredentialRequestOptions,
} from "../../../../../base";
import type { operations } from "./public_api.types";

/**
 * `POST /public/v1/query/get_activity`
 */
export type TGetActivityResponse =
  operations["PublicApiService_GetActivity"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_activity`
 */
export type TGetActivityInput = { body: TGetActivityBody };

/**
 * `POST /public/v1/query/get_activity`
 */
export type TGetActivityBody =
  operations["PublicApiService_GetActivity"]["parameters"]["body"]["body"];

/**
 * Get Activity
 *
 * Get details about an Activity
 *
 * `POST /public/v1/query/get_activity`
 */
export const getActivity = (input: TGetActivityInput) =>
  request<TGetActivityResponse, TGetActivityBody, never, never, never>({
    uri: "/public/v1/query/get_activity",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetActivity` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetActivity}
 */
export const signGetActivity = (
  input: TGetActivityInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetActivityBody, never, never>({
    uri: "/public/v1/query/get_activity",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_api_key`
 */
export type TGetApiKeyResponse =
  operations["PublicApiService_GetApiKey"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_api_key`
 */
export type TGetApiKeyInput = { body: TGetApiKeyBody };

/**
 * `POST /public/v1/query/get_api_key`
 */
export type TGetApiKeyBody =
  operations["PublicApiService_GetApiKey"]["parameters"]["body"]["body"];

/**
 * Get API key
 *
 * Get details about an API key
 *
 * `POST /public/v1/query/get_api_key`
 */
export const getApiKey = (input: TGetApiKeyInput) =>
  request<TGetApiKeyResponse, TGetApiKeyBody, never, never, never>({
    uri: "/public/v1/query/get_api_key",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetApiKey` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetApiKey}
 */
export const signGetApiKey = (
  input: TGetApiKeyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetApiKeyBody, never, never>({
    uri: "/public/v1/query/get_api_key",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_api_keys`
 */
export type TGetApiKeysResponse =
  operations["PublicApiService_GetApiKeys"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_api_keys`
 */
export type TGetApiKeysInput = { body: TGetApiKeysBody };

/**
 * `POST /public/v1/query/get_api_keys`
 */
export type TGetApiKeysBody =
  operations["PublicApiService_GetApiKeys"]["parameters"]["body"]["body"];

/**
 * Get API key
 *
 * Get details about API keys for a user
 *
 * `POST /public/v1/query/get_api_keys`
 */
export const getApiKeys = (input: TGetApiKeysInput) =>
  request<TGetApiKeysResponse, TGetApiKeysBody, never, never, never>({
    uri: "/public/v1/query/get_api_keys",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetApiKeys` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetApiKeys}
 */
export const signGetApiKeys = (
  input: TGetApiKeysInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetApiKeysBody, never, never>({
    uri: "/public/v1/query/get_api_keys",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_attestation`
 */
export type TGetAttestationDocumentResponse =
  operations["PublicApiService_GetAttestationDocument"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_attestation`
 */
export type TGetAttestationDocumentInput = {
  body: TGetAttestationDocumentBody;
};

/**
 * `POST /public/v1/query/get_attestation`
 */
export type TGetAttestationDocumentBody =
  operations["PublicApiService_GetAttestationDocument"]["parameters"]["body"]["body"];

/**
 * Attestation
 *
 * Get the attestation document corresponding to an enclave.
 *
 * `POST /public/v1/query/get_attestation`
 */
export const getAttestationDocument = (input: TGetAttestationDocumentInput) =>
  request<
    TGetAttestationDocumentResponse,
    TGetAttestationDocumentBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/get_attestation",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetAttestationDocument` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetAttestationDocument}
 */
export const signGetAttestationDocument = (
  input: TGetAttestationDocumentInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetAttestationDocumentBody, never, never>({
    uri: "/public/v1/query/get_attestation",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_authenticator`
 */
export type TGetAuthenticatorResponse =
  operations["PublicApiService_GetAuthenticator"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_authenticator`
 */
export type TGetAuthenticatorInput = { body: TGetAuthenticatorBody };

/**
 * `POST /public/v1/query/get_authenticator`
 */
export type TGetAuthenticatorBody =
  operations["PublicApiService_GetAuthenticator"]["parameters"]["body"]["body"];

/**
 * Get Authenticator
 *
 * Get details about an authenticator
 *
 * `POST /public/v1/query/get_authenticator`
 */
export const getAuthenticator = (input: TGetAuthenticatorInput) =>
  request<
    TGetAuthenticatorResponse,
    TGetAuthenticatorBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/get_authenticator",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetAuthenticator` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetAuthenticator}
 */
export const signGetAuthenticator = (
  input: TGetAuthenticatorInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetAuthenticatorBody, never, never>({
    uri: "/public/v1/query/get_authenticator",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_authenticators`
 */
export type TGetAuthenticatorsResponse =
  operations["PublicApiService_GetAuthenticators"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_authenticators`
 */
export type TGetAuthenticatorsInput = { body: TGetAuthenticatorsBody };

/**
 * `POST /public/v1/query/get_authenticators`
 */
export type TGetAuthenticatorsBody =
  operations["PublicApiService_GetAuthenticators"]["parameters"]["body"]["body"];

/**
 * Get Authenticators
 *
 * Get details about authenticators for a user
 *
 * `POST /public/v1/query/get_authenticators`
 */
export const getAuthenticators = (input: TGetAuthenticatorsInput) =>
  request<
    TGetAuthenticatorsResponse,
    TGetAuthenticatorsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/get_authenticators",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetAuthenticators` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetAuthenticators}
 */
export const signGetAuthenticators = (
  input: TGetAuthenticatorsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetAuthenticatorsBody, never, never>({
    uri: "/public/v1/query/get_authenticators",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_oauth_providers`
 */
export type TGetOauthProvidersResponse =
  operations["PublicApiService_GetOauthProviders"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_oauth_providers`
 */
export type TGetOauthProvidersInput = { body: TGetOauthProvidersBody };

/**
 * `POST /public/v1/query/get_oauth_providers`
 */
export type TGetOauthProvidersBody =
  operations["PublicApiService_GetOauthProviders"]["parameters"]["body"]["body"];

/**
 * Get Oauth providers
 *
 * Get details about Oauth providers for a user
 *
 * `POST /public/v1/query/get_oauth_providers`
 */
export const getOauthProviders = (input: TGetOauthProvidersInput) =>
  request<
    TGetOauthProvidersResponse,
    TGetOauthProvidersBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/get_oauth_providers",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetOauthProviders` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetOauthProviders}
 */
export const signGetOauthProviders = (
  input: TGetOauthProvidersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetOauthProvidersBody, never, never>({
    uri: "/public/v1/query/get_oauth_providers",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_organization`
 */
export type TGetOrganizationResponse =
  operations["PublicApiService_GetOrganization"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_organization`
 */
export type TGetOrganizationInput = { body: TGetOrganizationBody };

/**
 * `POST /public/v1/query/get_organization`
 */
export type TGetOrganizationBody =
  operations["PublicApiService_GetOrganization"]["parameters"]["body"]["body"];

/**
 * Get Organization
 *
 * Get details about an Organization
 *
 * `POST /public/v1/query/get_organization`
 */
export const getOrganization = (input: TGetOrganizationInput) =>
  request<TGetOrganizationResponse, TGetOrganizationBody, never, never, never>({
    uri: "/public/v1/query/get_organization",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetOrganization` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetOrganization}
 */
export const signGetOrganization = (
  input: TGetOrganizationInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetOrganizationBody, never, never>({
    uri: "/public/v1/query/get_organization",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_organization_configs`
 */
export type TGetOrganizationConfigsResponse =
  operations["PublicApiService_GetOrganizationConfigs"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_organization_configs`
 */
export type TGetOrganizationConfigsInput = {
  body: TGetOrganizationConfigsBody;
};

/**
 * `POST /public/v1/query/get_organization_configs`
 */
export type TGetOrganizationConfigsBody =
  operations["PublicApiService_GetOrganizationConfigs"]["parameters"]["body"]["body"];

/**
 * Get Configs
 *
 * Get quorum settings and features for an organization
 *
 * `POST /public/v1/query/get_organization_configs`
 */
export const getOrganizationConfigs = (input: TGetOrganizationConfigsInput) =>
  request<
    TGetOrganizationConfigsResponse,
    TGetOrganizationConfigsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/get_organization_configs",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetOrganizationConfigs` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetOrganizationConfigs}
 */
export const signGetOrganizationConfigs = (
  input: TGetOrganizationConfigsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetOrganizationConfigsBody, never, never>({
    uri: "/public/v1/query/get_organization_configs",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_policy`
 */
export type TGetPolicyResponse =
  operations["PublicApiService_GetPolicy"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_policy`
 */
export type TGetPolicyInput = { body: TGetPolicyBody };

/**
 * `POST /public/v1/query/get_policy`
 */
export type TGetPolicyBody =
  operations["PublicApiService_GetPolicy"]["parameters"]["body"]["body"];

/**
 * Get Policy
 *
 * Get details about a Policy
 *
 * `POST /public/v1/query/get_policy`
 */
export const getPolicy = (input: TGetPolicyInput) =>
  request<TGetPolicyResponse, TGetPolicyBody, never, never, never>({
    uri: "/public/v1/query/get_policy",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetPolicy` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetPolicy}
 */
export const signGetPolicy = (
  input: TGetPolicyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetPolicyBody, never, never>({
    uri: "/public/v1/query/get_policy",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_private_key`
 */
export type TGetPrivateKeyResponse =
  operations["PublicApiService_GetPrivateKey"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_private_key`
 */
export type TGetPrivateKeyInput = { body: TGetPrivateKeyBody };

/**
 * `POST /public/v1/query/get_private_key`
 */
export type TGetPrivateKeyBody =
  operations["PublicApiService_GetPrivateKey"]["parameters"]["body"]["body"];

/**
 * Get Private Key
 *
 * Get details about a Private Key
 *
 * `POST /public/v1/query/get_private_key`
 */
export const getPrivateKey = (input: TGetPrivateKeyInput) =>
  request<TGetPrivateKeyResponse, TGetPrivateKeyBody, never, never, never>({
    uri: "/public/v1/query/get_private_key",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetPrivateKey` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetPrivateKey}
 */
export const signGetPrivateKey = (
  input: TGetPrivateKeyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetPrivateKeyBody, never, never>({
    uri: "/public/v1/query/get_private_key",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_user`
 */
export type TGetUserResponse =
  operations["PublicApiService_GetUser"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_user`
 */
export type TGetUserInput = { body: TGetUserBody };

/**
 * `POST /public/v1/query/get_user`
 */
export type TGetUserBody =
  operations["PublicApiService_GetUser"]["parameters"]["body"]["body"];

/**
 * Get User
 *
 * Get details about a User
 *
 * `POST /public/v1/query/get_user`
 */
export const getUser = (input: TGetUserInput) =>
  request<TGetUserResponse, TGetUserBody, never, never, never>({
    uri: "/public/v1/query/get_user",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetUser` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetUser}
 */
export const signGetUser = (
  input: TGetUserInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetUserBody, never, never>({
    uri: "/public/v1/query/get_user",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/get_wallet`
 */
export type TGetWalletResponse =
  operations["PublicApiService_GetWallet"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/get_wallet`
 */
export type TGetWalletInput = { body: TGetWalletBody };

/**
 * `POST /public/v1/query/get_wallet`
 */
export type TGetWalletBody =
  operations["PublicApiService_GetWallet"]["parameters"]["body"]["body"];

/**
 * Get Wallet
 *
 * Get details about a Wallet
 *
 * `POST /public/v1/query/get_wallet`
 */
export const getWallet = (input: TGetWalletInput) =>
  request<TGetWalletResponse, TGetWalletBody, never, never, never>({
    uri: "/public/v1/query/get_wallet",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetWallet` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetWallet}
 */
export const signGetWallet = (
  input: TGetWalletInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetWalletBody, never, never>({
    uri: "/public/v1/query/get_wallet",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_activities`
 */
export type TGetActivitiesResponse =
  operations["PublicApiService_GetActivities"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_activities`
 */
export type TGetActivitiesInput = { body: TGetActivitiesBody };

/**
 * `POST /public/v1/query/list_activities`
 */
export type TGetActivitiesBody =
  operations["PublicApiService_GetActivities"]["parameters"]["body"]["body"];

/**
 * List Activities
 *
 * List all Activities within an Organization
 *
 * `POST /public/v1/query/list_activities`
 */
export const getActivities = (input: TGetActivitiesInput) =>
  request<TGetActivitiesResponse, TGetActivitiesBody, never, never, never>({
    uri: "/public/v1/query/list_activities",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetActivities` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetActivities}
 */
export const signGetActivities = (
  input: TGetActivitiesInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetActivitiesBody, never, never>({
    uri: "/public/v1/query/list_activities",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_policies`
 */
export type TGetPoliciesResponse =
  operations["PublicApiService_GetPolicies"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_policies`
 */
export type TGetPoliciesInput = { body: TGetPoliciesBody };

/**
 * `POST /public/v1/query/list_policies`
 */
export type TGetPoliciesBody =
  operations["PublicApiService_GetPolicies"]["parameters"]["body"]["body"];

/**
 * List Policies
 *
 * List all Policies within an Organization
 *
 * `POST /public/v1/query/list_policies`
 */
export const getPolicies = (input: TGetPoliciesInput) =>
  request<TGetPoliciesResponse, TGetPoliciesBody, never, never, never>({
    uri: "/public/v1/query/list_policies",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetPolicies` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetPolicies}
 */
export const signGetPolicies = (
  input: TGetPoliciesInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetPoliciesBody, never, never>({
    uri: "/public/v1/query/list_policies",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_private_key_tags`
 */
export type TListPrivateKeyTagsResponse =
  operations["PublicApiService_ListPrivateKeyTags"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_private_key_tags`
 */
export type TListPrivateKeyTagsInput = { body: TListPrivateKeyTagsBody };

/**
 * `POST /public/v1/query/list_private_key_tags`
 */
export type TListPrivateKeyTagsBody =
  operations["PublicApiService_ListPrivateKeyTags"]["parameters"]["body"]["body"];

/**
 * List Private Key Tags
 *
 * List all Private Key Tags within an Organization
 *
 * `POST /public/v1/query/list_private_key_tags`
 */
export const listPrivateKeyTags = (input: TListPrivateKeyTagsInput) =>
  request<
    TListPrivateKeyTagsResponse,
    TListPrivateKeyTagsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/list_private_key_tags",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ListPrivateKeyTags` request, ready to be POSTed to Turnkey.
 *
 * See {@link ListPrivateKeyTags}
 */
export const signListPrivateKeyTags = (
  input: TListPrivateKeyTagsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TListPrivateKeyTagsBody, never, never>({
    uri: "/public/v1/query/list_private_key_tags",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_private_keys`
 */
export type TGetPrivateKeysResponse =
  operations["PublicApiService_GetPrivateKeys"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_private_keys`
 */
export type TGetPrivateKeysInput = { body: TGetPrivateKeysBody };

/**
 * `POST /public/v1/query/list_private_keys`
 */
export type TGetPrivateKeysBody =
  operations["PublicApiService_GetPrivateKeys"]["parameters"]["body"]["body"];

/**
 * List Private Keys
 *
 * List all Private Keys within an Organization
 *
 * `POST /public/v1/query/list_private_keys`
 */
export const getPrivateKeys = (input: TGetPrivateKeysInput) =>
  request<TGetPrivateKeysResponse, TGetPrivateKeysBody, never, never, never>({
    uri: "/public/v1/query/list_private_keys",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetPrivateKeys` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetPrivateKeys}
 */
export const signGetPrivateKeys = (
  input: TGetPrivateKeysInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetPrivateKeysBody, never, never>({
    uri: "/public/v1/query/list_private_keys",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_suborgs`
 */
export type TGetSubOrgIdsResponse =
  operations["PublicApiService_GetSubOrgIds"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_suborgs`
 */
export type TGetSubOrgIdsInput = { body: TGetSubOrgIdsBody };

/**
 * `POST /public/v1/query/list_suborgs`
 */
export type TGetSubOrgIdsBody =
  operations["PublicApiService_GetSubOrgIds"]["parameters"]["body"]["body"];

/**
 * Get Suborgs
 *
 * Get all suborg IDs associated given a parent org ID and an optional filter.
 *
 * `POST /public/v1/query/list_suborgs`
 */
export const getSubOrgIds = (input: TGetSubOrgIdsInput) =>
  request<TGetSubOrgIdsResponse, TGetSubOrgIdsBody, never, never, never>({
    uri: "/public/v1/query/list_suborgs",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetSubOrgIds` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetSubOrgIds}
 */
export const signGetSubOrgIds = (
  input: TGetSubOrgIdsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetSubOrgIdsBody, never, never>({
    uri: "/public/v1/query/list_suborgs",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_user_tags`
 */
export type TListUserTagsResponse =
  operations["PublicApiService_ListUserTags"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_user_tags`
 */
export type TListUserTagsInput = { body: TListUserTagsBody };

/**
 * `POST /public/v1/query/list_user_tags`
 */
export type TListUserTagsBody =
  operations["PublicApiService_ListUserTags"]["parameters"]["body"]["body"];

/**
 * List User Tags
 *
 * List all User Tags within an Organization
 *
 * `POST /public/v1/query/list_user_tags`
 */
export const listUserTags = (input: TListUserTagsInput) =>
  request<TListUserTagsResponse, TListUserTagsBody, never, never, never>({
    uri: "/public/v1/query/list_user_tags",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ListUserTags` request, ready to be POSTed to Turnkey.
 *
 * See {@link ListUserTags}
 */
export const signListUserTags = (
  input: TListUserTagsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TListUserTagsBody, never, never>({
    uri: "/public/v1/query/list_user_tags",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_users`
 */
export type TGetUsersResponse =
  operations["PublicApiService_GetUsers"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_users`
 */
export type TGetUsersInput = { body: TGetUsersBody };

/**
 * `POST /public/v1/query/list_users`
 */
export type TGetUsersBody =
  operations["PublicApiService_GetUsers"]["parameters"]["body"]["body"];

/**
 * List Users
 *
 * List all Users within an Organization
 *
 * `POST /public/v1/query/list_users`
 */
export const getUsers = (input: TGetUsersInput) =>
  request<TGetUsersResponse, TGetUsersBody, never, never, never>({
    uri: "/public/v1/query/list_users",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetUsers` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetUsers}
 */
export const signGetUsers = (
  input: TGetUsersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetUsersBody, never, never>({
    uri: "/public/v1/query/list_users",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_wallet_accounts`
 */
export type TGetWalletAccountsResponse =
  operations["PublicApiService_GetWalletAccounts"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_wallet_accounts`
 */
export type TGetWalletAccountsInput = { body: TGetWalletAccountsBody };

/**
 * `POST /public/v1/query/list_wallet_accounts`
 */
export type TGetWalletAccountsBody =
  operations["PublicApiService_GetWalletAccounts"]["parameters"]["body"]["body"];

/**
 * List Wallets Accounts
 *
 * List all Accounts wirhin a Wallet
 *
 * `POST /public/v1/query/list_wallet_accounts`
 */
export const getWalletAccounts = (input: TGetWalletAccountsInput) =>
  request<
    TGetWalletAccountsResponse,
    TGetWalletAccountsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/query/list_wallet_accounts",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetWalletAccounts` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetWalletAccounts}
 */
export const signGetWalletAccounts = (
  input: TGetWalletAccountsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetWalletAccountsBody, never, never>({
    uri: "/public/v1/query/list_wallet_accounts",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/list_wallets`
 */
export type TGetWalletsResponse =
  operations["PublicApiService_GetWallets"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/list_wallets`
 */
export type TGetWalletsInput = { body: TGetWalletsBody };

/**
 * `POST /public/v1/query/list_wallets`
 */
export type TGetWalletsBody =
  operations["PublicApiService_GetWallets"]["parameters"]["body"]["body"];

/**
 * List Wallets
 *
 * List all Wallets within an Organization
 *
 * `POST /public/v1/query/list_wallets`
 */
export const getWallets = (input: TGetWalletsInput) =>
  request<TGetWalletsResponse, TGetWalletsBody, never, never, never>({
    uri: "/public/v1/query/list_wallets",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetWallets` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetWallets}
 */
export const signGetWallets = (
  input: TGetWalletsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetWalletsBody, never, never>({
    uri: "/public/v1/query/list_wallets",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/query/whoami`
 */
export type TGetWhoamiResponse =
  operations["PublicApiService_GetWhoami"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/query/whoami`
 */
export type TGetWhoamiInput = { body: TGetWhoamiBody };

/**
 * `POST /public/v1/query/whoami`
 */
export type TGetWhoamiBody =
  operations["PublicApiService_GetWhoami"]["parameters"]["body"]["body"];

/**
 * Who am I?
 *
 * Get basic information about your current API or WebAuthN user and their organization. Affords Sub-Organization look ups via Parent Organization for WebAuthN or API key users.
 *
 * `POST /public/v1/query/whoami`
 */
export const getWhoami = (input: TGetWhoamiInput) =>
  request<TGetWhoamiResponse, TGetWhoamiBody, never, never, never>({
    uri: "/public/v1/query/whoami",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `GetWhoami` request, ready to be POSTed to Turnkey.
 *
 * See {@link GetWhoami}
 */
export const signGetWhoami = (
  input: TGetWhoamiInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TGetWhoamiBody, never, never>({
    uri: "/public/v1/query/whoami",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/approve_activity`
 */
export type TApproveActivityResponse =
  operations["PublicApiService_ApproveActivity"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/approve_activity`
 */
export type TApproveActivityInput = { body: TApproveActivityBody };

/**
 * `POST /public/v1/submit/approve_activity`
 */
export type TApproveActivityBody =
  operations["PublicApiService_ApproveActivity"]["parameters"]["body"]["body"];

/**
 * Approve Activity
 *
 * Approve an Activity
 *
 * `POST /public/v1/submit/approve_activity`
 */
export const approveActivity = (input: TApproveActivityInput) =>
  request<TApproveActivityResponse, TApproveActivityBody, never, never, never>({
    uri: "/public/v1/submit/approve_activity",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ApproveActivity` request, ready to be POSTed to Turnkey.
 *
 * See {@link ApproveActivity}
 */
export const signApproveActivity = (
  input: TApproveActivityInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TApproveActivityBody, never, never>({
    uri: "/public/v1/submit/approve_activity",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_api_keys`
 */
export type TCreateApiKeysResponse =
  operations["PublicApiService_CreateApiKeys"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_api_keys`
 */
export type TCreateApiKeysInput = { body: TCreateApiKeysBody };

/**
 * `POST /public/v1/submit/create_api_keys`
 */
export type TCreateApiKeysBody =
  operations["PublicApiService_CreateApiKeys"]["parameters"]["body"]["body"];

/**
 * Create API Keys
 *
 * Add api keys to an existing User
 *
 * `POST /public/v1/submit/create_api_keys`
 */
export const createApiKeys = (input: TCreateApiKeysInput) =>
  request<TCreateApiKeysResponse, TCreateApiKeysBody, never, never, never>({
    uri: "/public/v1/submit/create_api_keys",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateApiKeys` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateApiKeys}
 */
export const signCreateApiKeys = (
  input: TCreateApiKeysInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateApiKeysBody, never, never>({
    uri: "/public/v1/submit/create_api_keys",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_api_only_users`
 */
export type TCreateApiOnlyUsersResponse =
  operations["PublicApiService_CreateApiOnlyUsers"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_api_only_users`
 */
export type TCreateApiOnlyUsersInput = { body: TCreateApiOnlyUsersBody };

/**
 * `POST /public/v1/submit/create_api_only_users`
 */
export type TCreateApiOnlyUsersBody =
  operations["PublicApiService_CreateApiOnlyUsers"]["parameters"]["body"]["body"];

/**
 * Create API-only Users
 *
 * Create API-only Users in an existing Organization
 *
 * `POST /public/v1/submit/create_api_only_users`
 */
export const createApiOnlyUsers = (input: TCreateApiOnlyUsersInput) =>
  request<
    TCreateApiOnlyUsersResponse,
    TCreateApiOnlyUsersBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_api_only_users",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateApiOnlyUsers` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateApiOnlyUsers}
 */
export const signCreateApiOnlyUsers = (
  input: TCreateApiOnlyUsersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateApiOnlyUsersBody, never, never>({
    uri: "/public/v1/submit/create_api_only_users",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_authenticators`
 */
export type TCreateAuthenticatorsResponse =
  operations["PublicApiService_CreateAuthenticators"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_authenticators`
 */
export type TCreateAuthenticatorsInput = { body: TCreateAuthenticatorsBody };

/**
 * `POST /public/v1/submit/create_authenticators`
 */
export type TCreateAuthenticatorsBody =
  operations["PublicApiService_CreateAuthenticators"]["parameters"]["body"]["body"];

/**
 * Create Authenticators
 *
 * Create Authenticators to authenticate requests to Turnkey
 *
 * `POST /public/v1/submit/create_authenticators`
 */
export const createAuthenticators = (input: TCreateAuthenticatorsInput) =>
  request<
    TCreateAuthenticatorsResponse,
    TCreateAuthenticatorsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_authenticators",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateAuthenticators` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateAuthenticators}
 */
export const signCreateAuthenticators = (
  input: TCreateAuthenticatorsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateAuthenticatorsBody, never, never>({
    uri: "/public/v1/submit/create_authenticators",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_invitations`
 */
export type TCreateInvitationsResponse =
  operations["PublicApiService_CreateInvitations"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_invitations`
 */
export type TCreateInvitationsInput = { body: TCreateInvitationsBody };

/**
 * `POST /public/v1/submit/create_invitations`
 */
export type TCreateInvitationsBody =
  operations["PublicApiService_CreateInvitations"]["parameters"]["body"]["body"];

/**
 * Create Invitations
 *
 * Create Invitations to join an existing Organization
 *
 * `POST /public/v1/submit/create_invitations`
 */
export const createInvitations = (input: TCreateInvitationsInput) =>
  request<
    TCreateInvitationsResponse,
    TCreateInvitationsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_invitations",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateInvitations` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateInvitations}
 */
export const signCreateInvitations = (
  input: TCreateInvitationsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateInvitationsBody, never, never>({
    uri: "/public/v1/submit/create_invitations",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_oauth_providers`
 */
export type TCreateOauthProvidersResponse =
  operations["PublicApiService_CreateOauthProviders"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_oauth_providers`
 */
export type TCreateOauthProvidersInput = { body: TCreateOauthProvidersBody };

/**
 * `POST /public/v1/submit/create_oauth_providers`
 */
export type TCreateOauthProvidersBody =
  operations["PublicApiService_CreateOauthProviders"]["parameters"]["body"]["body"];

/**
 * Create Oauth Providers
 *
 * Creates Oauth providers for a specified user - BETA
 *
 * `POST /public/v1/submit/create_oauth_providers`
 */
export const createOauthProviders = (input: TCreateOauthProvidersInput) =>
  request<
    TCreateOauthProvidersResponse,
    TCreateOauthProvidersBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_oauth_providers",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateOauthProviders` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateOauthProviders}
 */
export const signCreateOauthProviders = (
  input: TCreateOauthProvidersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateOauthProvidersBody, never, never>({
    uri: "/public/v1/submit/create_oauth_providers",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_policies`
 */
export type TCreatePoliciesResponse =
  operations["PublicApiService_CreatePolicies"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_policies`
 */
export type TCreatePoliciesInput = { body: TCreatePoliciesBody };

/**
 * `POST /public/v1/submit/create_policies`
 */
export type TCreatePoliciesBody =
  operations["PublicApiService_CreatePolicies"]["parameters"]["body"]["body"];

/**
 * Create Policies
 *
 * Create new Policies
 *
 * `POST /public/v1/submit/create_policies`
 */
export const createPolicies = (input: TCreatePoliciesInput) =>
  request<TCreatePoliciesResponse, TCreatePoliciesBody, never, never, never>({
    uri: "/public/v1/submit/create_policies",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreatePolicies` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreatePolicies}
 */
export const signCreatePolicies = (
  input: TCreatePoliciesInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreatePoliciesBody, never, never>({
    uri: "/public/v1/submit/create_policies",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_policy`
 */
export type TCreatePolicyResponse =
  operations["PublicApiService_CreatePolicy"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_policy`
 */
export type TCreatePolicyInput = { body: TCreatePolicyBody };

/**
 * `POST /public/v1/submit/create_policy`
 */
export type TCreatePolicyBody =
  operations["PublicApiService_CreatePolicy"]["parameters"]["body"]["body"];

/**
 * Create Policy
 *
 * Create a new Policy
 *
 * `POST /public/v1/submit/create_policy`
 */
export const createPolicy = (input: TCreatePolicyInput) =>
  request<TCreatePolicyResponse, TCreatePolicyBody, never, never, never>({
    uri: "/public/v1/submit/create_policy",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreatePolicy` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreatePolicy}
 */
export const signCreatePolicy = (
  input: TCreatePolicyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreatePolicyBody, never, never>({
    uri: "/public/v1/submit/create_policy",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_private_key_tag`
 */
export type TCreatePrivateKeyTagResponse =
  operations["PublicApiService_CreatePrivateKeyTag"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_private_key_tag`
 */
export type TCreatePrivateKeyTagInput = { body: TCreatePrivateKeyTagBody };

/**
 * `POST /public/v1/submit/create_private_key_tag`
 */
export type TCreatePrivateKeyTagBody =
  operations["PublicApiService_CreatePrivateKeyTag"]["parameters"]["body"]["body"];

/**
 * Create Private Key Tag
 *
 * Create a private key tag and add it to private keys.
 *
 * `POST /public/v1/submit/create_private_key_tag`
 */
export const createPrivateKeyTag = (input: TCreatePrivateKeyTagInput) =>
  request<
    TCreatePrivateKeyTagResponse,
    TCreatePrivateKeyTagBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_private_key_tag",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreatePrivateKeyTag` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreatePrivateKeyTag}
 */
export const signCreatePrivateKeyTag = (
  input: TCreatePrivateKeyTagInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreatePrivateKeyTagBody, never, never>({
    uri: "/public/v1/submit/create_private_key_tag",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_private_keys`
 */
export type TCreatePrivateKeysResponse =
  operations["PublicApiService_CreatePrivateKeys"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_private_keys`
 */
export type TCreatePrivateKeysInput = { body: TCreatePrivateKeysBody };

/**
 * `POST /public/v1/submit/create_private_keys`
 */
export type TCreatePrivateKeysBody =
  operations["PublicApiService_CreatePrivateKeys"]["parameters"]["body"]["body"];

/**
 * Create Private Keys
 *
 * Create new Private Keys
 *
 * `POST /public/v1/submit/create_private_keys`
 */
export const createPrivateKeys = (input: TCreatePrivateKeysInput) =>
  request<
    TCreatePrivateKeysResponse,
    TCreatePrivateKeysBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_private_keys",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreatePrivateKeys` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreatePrivateKeys}
 */
export const signCreatePrivateKeys = (
  input: TCreatePrivateKeysInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreatePrivateKeysBody, never, never>({
    uri: "/public/v1/submit/create_private_keys",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_read_only_session`
 */
export type TCreateReadOnlySessionResponse =
  operations["PublicApiService_CreateReadOnlySession"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_read_only_session`
 */
export type TCreateReadOnlySessionInput = { body: TCreateReadOnlySessionBody };

/**
 * `POST /public/v1/submit/create_read_only_session`
 */
export type TCreateReadOnlySessionBody =
  operations["PublicApiService_CreateReadOnlySession"]["parameters"]["body"]["body"];

/**
 * Create Read Only Session
 *
 * Create a read only session for a user (valid for 1 hour)
 *
 * `POST /public/v1/submit/create_read_only_session`
 */
export const createReadOnlySession = (input: TCreateReadOnlySessionInput) =>
  request<
    TCreateReadOnlySessionResponse,
    TCreateReadOnlySessionBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_read_only_session",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateReadOnlySession` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateReadOnlySession}
 */
export const signCreateReadOnlySession = (
  input: TCreateReadOnlySessionInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateReadOnlySessionBody, never, never>({
    uri: "/public/v1/submit/create_read_only_session",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_read_write_session`
 */
export type TCreateReadWriteSessionResponse =
  operations["PublicApiService_CreateReadWriteSession"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_read_write_session`
 */
export type TCreateReadWriteSessionInput = {
  body: TCreateReadWriteSessionBody;
};

/**
 * `POST /public/v1/submit/create_read_write_session`
 */
export type TCreateReadWriteSessionBody =
  operations["PublicApiService_CreateReadWriteSession"]["parameters"]["body"]["body"];

/**
 * Create Read Write Session
 *
 * Create a read write session for a user
 *
 * `POST /public/v1/submit/create_read_write_session`
 */
export const createReadWriteSession = (input: TCreateReadWriteSessionInput) =>
  request<
    TCreateReadWriteSessionResponse,
    TCreateReadWriteSessionBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_read_write_session",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateReadWriteSession` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateReadWriteSession}
 */
export const signCreateReadWriteSession = (
  input: TCreateReadWriteSessionInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateReadWriteSessionBody, never, never>({
    uri: "/public/v1/submit/create_read_write_session",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_sub_organization`
 */
export type TCreateSubOrganizationResponse =
  operations["PublicApiService_CreateSubOrganization"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_sub_organization`
 */
export type TCreateSubOrganizationInput = { body: TCreateSubOrganizationBody };

/**
 * `POST /public/v1/submit/create_sub_organization`
 */
export type TCreateSubOrganizationBody =
  operations["PublicApiService_CreateSubOrganization"]["parameters"]["body"]["body"];

/**
 * Create Sub-Organization
 *
 * Create a new Sub-Organization
 *
 * `POST /public/v1/submit/create_sub_organization`
 */
export const createSubOrganization = (input: TCreateSubOrganizationInput) =>
  request<
    TCreateSubOrganizationResponse,
    TCreateSubOrganizationBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_sub_organization",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateSubOrganization` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateSubOrganization}
 */
export const signCreateSubOrganization = (
  input: TCreateSubOrganizationInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateSubOrganizationBody, never, never>({
    uri: "/public/v1/submit/create_sub_organization",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_user_tag`
 */
export type TCreateUserTagResponse =
  operations["PublicApiService_CreateUserTag"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_user_tag`
 */
export type TCreateUserTagInput = { body: TCreateUserTagBody };

/**
 * `POST /public/v1/submit/create_user_tag`
 */
export type TCreateUserTagBody =
  operations["PublicApiService_CreateUserTag"]["parameters"]["body"]["body"];

/**
 * Create User Tag
 *
 * Create a user tag and add it to users.
 *
 * `POST /public/v1/submit/create_user_tag`
 */
export const createUserTag = (input: TCreateUserTagInput) =>
  request<TCreateUserTagResponse, TCreateUserTagBody, never, never, never>({
    uri: "/public/v1/submit/create_user_tag",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateUserTag` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateUserTag}
 */
export const signCreateUserTag = (
  input: TCreateUserTagInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateUserTagBody, never, never>({
    uri: "/public/v1/submit/create_user_tag",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_users`
 */
export type TCreateUsersResponse =
  operations["PublicApiService_CreateUsers"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_users`
 */
export type TCreateUsersInput = { body: TCreateUsersBody };

/**
 * `POST /public/v1/submit/create_users`
 */
export type TCreateUsersBody =
  operations["PublicApiService_CreateUsers"]["parameters"]["body"]["body"];

/**
 * Create Users
 *
 * Create Users in an existing Organization
 *
 * `POST /public/v1/submit/create_users`
 */
export const createUsers = (input: TCreateUsersInput) =>
  request<TCreateUsersResponse, TCreateUsersBody, never, never, never>({
    uri: "/public/v1/submit/create_users",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateUsers` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateUsers}
 */
export const signCreateUsers = (
  input: TCreateUsersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateUsersBody, never, never>({
    uri: "/public/v1/submit/create_users",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_wallet`
 */
export type TCreateWalletResponse =
  operations["PublicApiService_CreateWallet"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_wallet`
 */
export type TCreateWalletInput = { body: TCreateWalletBody };

/**
 * `POST /public/v1/submit/create_wallet`
 */
export type TCreateWalletBody =
  operations["PublicApiService_CreateWallet"]["parameters"]["body"]["body"];

/**
 * Create Wallet
 *
 * Create a Wallet and derive addresses
 *
 * `POST /public/v1/submit/create_wallet`
 */
export const createWallet = (input: TCreateWalletInput) =>
  request<TCreateWalletResponse, TCreateWalletBody, never, never, never>({
    uri: "/public/v1/submit/create_wallet",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateWallet` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateWallet}
 */
export const signCreateWallet = (
  input: TCreateWalletInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateWalletBody, never, never>({
    uri: "/public/v1/submit/create_wallet",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/create_wallet_accounts`
 */
export type TCreateWalletAccountsResponse =
  operations["PublicApiService_CreateWalletAccounts"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/create_wallet_accounts`
 */
export type TCreateWalletAccountsInput = { body: TCreateWalletAccountsBody };

/**
 * `POST /public/v1/submit/create_wallet_accounts`
 */
export type TCreateWalletAccountsBody =
  operations["PublicApiService_CreateWalletAccounts"]["parameters"]["body"]["body"];

/**
 * Create Wallet Accounts
 *
 * Derive additional addresses using an existing wallet
 *
 * `POST /public/v1/submit/create_wallet_accounts`
 */
export const createWalletAccounts = (input: TCreateWalletAccountsInput) =>
  request<
    TCreateWalletAccountsResponse,
    TCreateWalletAccountsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/create_wallet_accounts",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `CreateWalletAccounts` request, ready to be POSTed to Turnkey.
 *
 * See {@link CreateWalletAccounts}
 */
export const signCreateWalletAccounts = (
  input: TCreateWalletAccountsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TCreateWalletAccountsBody, never, never>({
    uri: "/public/v1/submit/create_wallet_accounts",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_api_keys`
 */
export type TDeleteApiKeysResponse =
  operations["PublicApiService_DeleteApiKeys"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_api_keys`
 */
export type TDeleteApiKeysInput = { body: TDeleteApiKeysBody };

/**
 * `POST /public/v1/submit/delete_api_keys`
 */
export type TDeleteApiKeysBody =
  operations["PublicApiService_DeleteApiKeys"]["parameters"]["body"]["body"];

/**
 * Delete API Keys
 *
 * Remove api keys from a User
 *
 * `POST /public/v1/submit/delete_api_keys`
 */
export const deleteApiKeys = (input: TDeleteApiKeysInput) =>
  request<TDeleteApiKeysResponse, TDeleteApiKeysBody, never, never, never>({
    uri: "/public/v1/submit/delete_api_keys",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeleteApiKeys` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeleteApiKeys}
 */
export const signDeleteApiKeys = (
  input: TDeleteApiKeysInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeleteApiKeysBody, never, never>({
    uri: "/public/v1/submit/delete_api_keys",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_authenticators`
 */
export type TDeleteAuthenticatorsResponse =
  operations["PublicApiService_DeleteAuthenticators"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_authenticators`
 */
export type TDeleteAuthenticatorsInput = { body: TDeleteAuthenticatorsBody };

/**
 * `POST /public/v1/submit/delete_authenticators`
 */
export type TDeleteAuthenticatorsBody =
  operations["PublicApiService_DeleteAuthenticators"]["parameters"]["body"]["body"];

/**
 * Delete Authenticators
 *
 * Remove authenticators from a User
 *
 * `POST /public/v1/submit/delete_authenticators`
 */
export const deleteAuthenticators = (input: TDeleteAuthenticatorsInput) =>
  request<
    TDeleteAuthenticatorsResponse,
    TDeleteAuthenticatorsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/delete_authenticators",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeleteAuthenticators` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeleteAuthenticators}
 */
export const signDeleteAuthenticators = (
  input: TDeleteAuthenticatorsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeleteAuthenticatorsBody, never, never>({
    uri: "/public/v1/submit/delete_authenticators",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_invitation`
 */
export type TDeleteInvitationResponse =
  operations["PublicApiService_DeleteInvitation"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_invitation`
 */
export type TDeleteInvitationInput = { body: TDeleteInvitationBody };

/**
 * `POST /public/v1/submit/delete_invitation`
 */
export type TDeleteInvitationBody =
  operations["PublicApiService_DeleteInvitation"]["parameters"]["body"]["body"];

/**
 * Delete Invitation
 *
 * Delete an existing Invitation
 *
 * `POST /public/v1/submit/delete_invitation`
 */
export const deleteInvitation = (input: TDeleteInvitationInput) =>
  request<
    TDeleteInvitationResponse,
    TDeleteInvitationBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/delete_invitation",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeleteInvitation` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeleteInvitation}
 */
export const signDeleteInvitation = (
  input: TDeleteInvitationInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeleteInvitationBody, never, never>({
    uri: "/public/v1/submit/delete_invitation",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_oauth_providers`
 */
export type TDeleteOauthProvidersResponse =
  operations["PublicApiService_DeleteOauthProviders"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_oauth_providers`
 */
export type TDeleteOauthProvidersInput = { body: TDeleteOauthProvidersBody };

/**
 * `POST /public/v1/submit/delete_oauth_providers`
 */
export type TDeleteOauthProvidersBody =
  operations["PublicApiService_DeleteOauthProviders"]["parameters"]["body"]["body"];

/**
 * Delete Oauth Providers
 *
 * Removes Oauth providers for a specified user - BETA
 *
 * `POST /public/v1/submit/delete_oauth_providers`
 */
export const deleteOauthProviders = (input: TDeleteOauthProvidersInput) =>
  request<
    TDeleteOauthProvidersResponse,
    TDeleteOauthProvidersBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/delete_oauth_providers",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeleteOauthProviders` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeleteOauthProviders}
 */
export const signDeleteOauthProviders = (
  input: TDeleteOauthProvidersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeleteOauthProvidersBody, never, never>({
    uri: "/public/v1/submit/delete_oauth_providers",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_policy`
 */
export type TDeletePolicyResponse =
  operations["PublicApiService_DeletePolicy"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_policy`
 */
export type TDeletePolicyInput = { body: TDeletePolicyBody };

/**
 * `POST /public/v1/submit/delete_policy`
 */
export type TDeletePolicyBody =
  operations["PublicApiService_DeletePolicy"]["parameters"]["body"]["body"];

/**
 * Delete Policy
 *
 * Delete an existing Policy
 *
 * `POST /public/v1/submit/delete_policy`
 */
export const deletePolicy = (input: TDeletePolicyInput) =>
  request<TDeletePolicyResponse, TDeletePolicyBody, never, never, never>({
    uri: "/public/v1/submit/delete_policy",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeletePolicy` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeletePolicy}
 */
export const signDeletePolicy = (
  input: TDeletePolicyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeletePolicyBody, never, never>({
    uri: "/public/v1/submit/delete_policy",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_private_key_tags`
 */
export type TDeletePrivateKeyTagsResponse =
  operations["PublicApiService_DeletePrivateKeyTags"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_private_key_tags`
 */
export type TDeletePrivateKeyTagsInput = { body: TDeletePrivateKeyTagsBody };

/**
 * `POST /public/v1/submit/delete_private_key_tags`
 */
export type TDeletePrivateKeyTagsBody =
  operations["PublicApiService_DeletePrivateKeyTags"]["parameters"]["body"]["body"];

/**
 * Delete Private Key Tags
 *
 * Delete Private Key Tags within an Organization
 *
 * `POST /public/v1/submit/delete_private_key_tags`
 */
export const deletePrivateKeyTags = (input: TDeletePrivateKeyTagsInput) =>
  request<
    TDeletePrivateKeyTagsResponse,
    TDeletePrivateKeyTagsBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/delete_private_key_tags",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeletePrivateKeyTags` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeletePrivateKeyTags}
 */
export const signDeletePrivateKeyTags = (
  input: TDeletePrivateKeyTagsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeletePrivateKeyTagsBody, never, never>({
    uri: "/public/v1/submit/delete_private_key_tags",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_user_tags`
 */
export type TDeleteUserTagsResponse =
  operations["PublicApiService_DeleteUserTags"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_user_tags`
 */
export type TDeleteUserTagsInput = { body: TDeleteUserTagsBody };

/**
 * `POST /public/v1/submit/delete_user_tags`
 */
export type TDeleteUserTagsBody =
  operations["PublicApiService_DeleteUserTags"]["parameters"]["body"]["body"];

/**
 * Delete User Tags
 *
 * Delete User Tags within an Organization
 *
 * `POST /public/v1/submit/delete_user_tags`
 */
export const deleteUserTags = (input: TDeleteUserTagsInput) =>
  request<TDeleteUserTagsResponse, TDeleteUserTagsBody, never, never, never>({
    uri: "/public/v1/submit/delete_user_tags",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeleteUserTags` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeleteUserTags}
 */
export const signDeleteUserTags = (
  input: TDeleteUserTagsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeleteUserTagsBody, never, never>({
    uri: "/public/v1/submit/delete_user_tags",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/delete_users`
 */
export type TDeleteUsersResponse =
  operations["PublicApiService_DeleteUsers"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/delete_users`
 */
export type TDeleteUsersInput = { body: TDeleteUsersBody };

/**
 * `POST /public/v1/submit/delete_users`
 */
export type TDeleteUsersBody =
  operations["PublicApiService_DeleteUsers"]["parameters"]["body"]["body"];

/**
 * Delete Users
 *
 * Delete Users within an Organization
 *
 * `POST /public/v1/submit/delete_users`
 */
export const deleteUsers = (input: TDeleteUsersInput) =>
  request<TDeleteUsersResponse, TDeleteUsersBody, never, never, never>({
    uri: "/public/v1/submit/delete_users",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `DeleteUsers` request, ready to be POSTed to Turnkey.
 *
 * See {@link DeleteUsers}
 */
export const signDeleteUsers = (
  input: TDeleteUsersInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TDeleteUsersBody, never, never>({
    uri: "/public/v1/submit/delete_users",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/email_auth`
 */
export type TEmailAuthResponse =
  operations["PublicApiService_EmailAuth"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/email_auth`
 */
export type TEmailAuthInput = { body: TEmailAuthBody };

/**
 * `POST /public/v1/submit/email_auth`
 */
export type TEmailAuthBody =
  operations["PublicApiService_EmailAuth"]["parameters"]["body"]["body"];

/**
 * Perform Email Auth
 *
 * Authenticate a user via Email
 *
 * `POST /public/v1/submit/email_auth`
 */
export const emailAuth = (input: TEmailAuthInput) =>
  request<TEmailAuthResponse, TEmailAuthBody, never, never, never>({
    uri: "/public/v1/submit/email_auth",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `EmailAuth` request, ready to be POSTed to Turnkey.
 *
 * See {@link EmailAuth}
 */
export const signEmailAuth = (
  input: TEmailAuthInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TEmailAuthBody, never, never>({
    uri: "/public/v1/submit/email_auth",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/export_private_key`
 */
export type TExportPrivateKeyResponse =
  operations["PublicApiService_ExportPrivateKey"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/export_private_key`
 */
export type TExportPrivateKeyInput = { body: TExportPrivateKeyBody };

/**
 * `POST /public/v1/submit/export_private_key`
 */
export type TExportPrivateKeyBody =
  operations["PublicApiService_ExportPrivateKey"]["parameters"]["body"]["body"];

/**
 * Export Private Key
 *
 * Exports a Private Key
 *
 * `POST /public/v1/submit/export_private_key`
 */
export const exportPrivateKey = (input: TExportPrivateKeyInput) =>
  request<
    TExportPrivateKeyResponse,
    TExportPrivateKeyBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/export_private_key",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ExportPrivateKey` request, ready to be POSTed to Turnkey.
 *
 * See {@link ExportPrivateKey}
 */
export const signExportPrivateKey = (
  input: TExportPrivateKeyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TExportPrivateKeyBody, never, never>({
    uri: "/public/v1/submit/export_private_key",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/export_wallet`
 */
export type TExportWalletResponse =
  operations["PublicApiService_ExportWallet"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/export_wallet`
 */
export type TExportWalletInput = { body: TExportWalletBody };

/**
 * `POST /public/v1/submit/export_wallet`
 */
export type TExportWalletBody =
  operations["PublicApiService_ExportWallet"]["parameters"]["body"]["body"];

/**
 * Export Wallet
 *
 * Exports a Wallet
 *
 * `POST /public/v1/submit/export_wallet`
 */
export const exportWallet = (input: TExportWalletInput) =>
  request<TExportWalletResponse, TExportWalletBody, never, never, never>({
    uri: "/public/v1/submit/export_wallet",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ExportWallet` request, ready to be POSTed to Turnkey.
 *
 * See {@link ExportWallet}
 */
export const signExportWallet = (
  input: TExportWalletInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TExportWalletBody, never, never>({
    uri: "/public/v1/submit/export_wallet",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/export_wallet_account`
 */
export type TExportWalletAccountResponse =
  operations["PublicApiService_ExportWalletAccount"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/export_wallet_account`
 */
export type TExportWalletAccountInput = { body: TExportWalletAccountBody };

/**
 * `POST /public/v1/submit/export_wallet_account`
 */
export type TExportWalletAccountBody =
  operations["PublicApiService_ExportWalletAccount"]["parameters"]["body"]["body"];

/**
 * Export Wallet Account
 *
 * Exports a Wallet Account
 *
 * `POST /public/v1/submit/export_wallet_account`
 */
export const exportWalletAccount = (input: TExportWalletAccountInput) =>
  request<
    TExportWalletAccountResponse,
    TExportWalletAccountBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/export_wallet_account",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ExportWalletAccount` request, ready to be POSTed to Turnkey.
 *
 * See {@link ExportWalletAccount}
 */
export const signExportWalletAccount = (
  input: TExportWalletAccountInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TExportWalletAccountBody, never, never>({
    uri: "/public/v1/submit/export_wallet_account",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/import_private_key`
 */
export type TImportPrivateKeyResponse =
  operations["PublicApiService_ImportPrivateKey"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/import_private_key`
 */
export type TImportPrivateKeyInput = { body: TImportPrivateKeyBody };

/**
 * `POST /public/v1/submit/import_private_key`
 */
export type TImportPrivateKeyBody =
  operations["PublicApiService_ImportPrivateKey"]["parameters"]["body"]["body"];

/**
 * Import Private Key
 *
 * Imports a private key
 *
 * `POST /public/v1/submit/import_private_key`
 */
export const importPrivateKey = (input: TImportPrivateKeyInput) =>
  request<
    TImportPrivateKeyResponse,
    TImportPrivateKeyBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/import_private_key",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ImportPrivateKey` request, ready to be POSTed to Turnkey.
 *
 * See {@link ImportPrivateKey}
 */
export const signImportPrivateKey = (
  input: TImportPrivateKeyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TImportPrivateKeyBody, never, never>({
    uri: "/public/v1/submit/import_private_key",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/import_wallet`
 */
export type TImportWalletResponse =
  operations["PublicApiService_ImportWallet"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/import_wallet`
 */
export type TImportWalletInput = { body: TImportWalletBody };

/**
 * `POST /public/v1/submit/import_wallet`
 */
export type TImportWalletBody =
  operations["PublicApiService_ImportWallet"]["parameters"]["body"]["body"];

/**
 * Import Wallet
 *
 * Imports a wallet
 *
 * `POST /public/v1/submit/import_wallet`
 */
export const importWallet = (input: TImportWalletInput) =>
  request<TImportWalletResponse, TImportWalletBody, never, never, never>({
    uri: "/public/v1/submit/import_wallet",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `ImportWallet` request, ready to be POSTed to Turnkey.
 *
 * See {@link ImportWallet}
 */
export const signImportWallet = (
  input: TImportWalletInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TImportWalletBody, never, never>({
    uri: "/public/v1/submit/import_wallet",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/init_import_private_key`
 */
export type TInitImportPrivateKeyResponse =
  operations["PublicApiService_InitImportPrivateKey"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/init_import_private_key`
 */
export type TInitImportPrivateKeyInput = { body: TInitImportPrivateKeyBody };

/**
 * `POST /public/v1/submit/init_import_private_key`
 */
export type TInitImportPrivateKeyBody =
  operations["PublicApiService_InitImportPrivateKey"]["parameters"]["body"]["body"];

/**
 * Init Import Private Key
 *
 * Initializes a new private key import
 *
 * `POST /public/v1/submit/init_import_private_key`
 */
export const initImportPrivateKey = (input: TInitImportPrivateKeyInput) =>
  request<
    TInitImportPrivateKeyResponse,
    TInitImportPrivateKeyBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/init_import_private_key",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `InitImportPrivateKey` request, ready to be POSTed to Turnkey.
 *
 * See {@link InitImportPrivateKey}
 */
export const signInitImportPrivateKey = (
  input: TInitImportPrivateKeyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TInitImportPrivateKeyBody, never, never>({
    uri: "/public/v1/submit/init_import_private_key",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/init_import_wallet`
 */
export type TInitImportWalletResponse =
  operations["PublicApiService_InitImportWallet"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/init_import_wallet`
 */
export type TInitImportWalletInput = { body: TInitImportWalletBody };

/**
 * `POST /public/v1/submit/init_import_wallet`
 */
export type TInitImportWalletBody =
  operations["PublicApiService_InitImportWallet"]["parameters"]["body"]["body"];

/**
 * Init Import Wallet
 *
 * Initializes a new wallet import
 *
 * `POST /public/v1/submit/init_import_wallet`
 */
export const initImportWallet = (input: TInitImportWalletInput) =>
  request<
    TInitImportWalletResponse,
    TInitImportWalletBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/init_import_wallet",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `InitImportWallet` request, ready to be POSTed to Turnkey.
 *
 * See {@link InitImportWallet}
 */
export const signInitImportWallet = (
  input: TInitImportWalletInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TInitImportWalletBody, never, never>({
    uri: "/public/v1/submit/init_import_wallet",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/init_user_email_recovery`
 */
export type TInitUserEmailRecoveryResponse =
  operations["PublicApiService_InitUserEmailRecovery"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/init_user_email_recovery`
 */
export type TInitUserEmailRecoveryInput = { body: TInitUserEmailRecoveryBody };

/**
 * `POST /public/v1/submit/init_user_email_recovery`
 */
export type TInitUserEmailRecoveryBody =
  operations["PublicApiService_InitUserEmailRecovery"]["parameters"]["body"]["body"];

/**
 * Init Email Recovery
 *
 * Initializes a new email recovery
 *
 * `POST /public/v1/submit/init_user_email_recovery`
 */
export const initUserEmailRecovery = (input: TInitUserEmailRecoveryInput) =>
  request<
    TInitUserEmailRecoveryResponse,
    TInitUserEmailRecoveryBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/init_user_email_recovery",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `InitUserEmailRecovery` request, ready to be POSTed to Turnkey.
 *
 * See {@link InitUserEmailRecovery}
 */
export const signInitUserEmailRecovery = (
  input: TInitUserEmailRecoveryInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TInitUserEmailRecoveryBody, never, never>({
    uri: "/public/v1/submit/init_user_email_recovery",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/oauth`
 */
export type TOauthResponse =
  operations["PublicApiService_Oauth"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/oauth`
 */
export type TOauthInput = { body: TOauthBody };

/**
 * `POST /public/v1/submit/oauth`
 */
export type TOauthBody =
  operations["PublicApiService_Oauth"]["parameters"]["body"]["body"];

/**
 * Oauth
 *
 * Authenticate a user with an Oidc token (Oauth) - BETA
 *
 * `POST /public/v1/submit/oauth`
 */
export const oauth = (input: TOauthInput) =>
  request<TOauthResponse, TOauthBody, never, never, never>({
    uri: "/public/v1/submit/oauth",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `Oauth` request, ready to be POSTed to Turnkey.
 *
 * See {@link Oauth}
 */
export const signOauth = (
  input: TOauthInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TOauthBody, never, never>({
    uri: "/public/v1/submit/oauth",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/recover_user`
 */
export type TRecoverUserResponse =
  operations["PublicApiService_RecoverUser"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/recover_user`
 */
export type TRecoverUserInput = { body: TRecoverUserBody };

/**
 * `POST /public/v1/submit/recover_user`
 */
export type TRecoverUserBody =
  operations["PublicApiService_RecoverUser"]["parameters"]["body"]["body"];

/**
 * Recover a user
 *
 * Completes the process of recovering a user by adding an authenticator
 *
 * `POST /public/v1/submit/recover_user`
 */
export const recoverUser = (input: TRecoverUserInput) =>
  request<TRecoverUserResponse, TRecoverUserBody, never, never, never>({
    uri: "/public/v1/submit/recover_user",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `RecoverUser` request, ready to be POSTed to Turnkey.
 *
 * See {@link RecoverUser}
 */
export const signRecoverUser = (
  input: TRecoverUserInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TRecoverUserBody, never, never>({
    uri: "/public/v1/submit/recover_user",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/reject_activity`
 */
export type TRejectActivityResponse =
  operations["PublicApiService_RejectActivity"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/reject_activity`
 */
export type TRejectActivityInput = { body: TRejectActivityBody };

/**
 * `POST /public/v1/submit/reject_activity`
 */
export type TRejectActivityBody =
  operations["PublicApiService_RejectActivity"]["parameters"]["body"]["body"];

/**
 * Reject Activity
 *
 * Reject an Activity
 *
 * `POST /public/v1/submit/reject_activity`
 */
export const rejectActivity = (input: TRejectActivityInput) =>
  request<TRejectActivityResponse, TRejectActivityBody, never, never, never>({
    uri: "/public/v1/submit/reject_activity",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `RejectActivity` request, ready to be POSTed to Turnkey.
 *
 * See {@link RejectActivity}
 */
export const signRejectActivity = (
  input: TRejectActivityInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TRejectActivityBody, never, never>({
    uri: "/public/v1/submit/reject_activity",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/remove_organization_feature`
 */
export type TRemoveOrganizationFeatureResponse =
  operations["PublicApiService_RemoveOrganizationFeature"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/remove_organization_feature`
 */
export type TRemoveOrganizationFeatureInput = {
  body: TRemoveOrganizationFeatureBody;
};

/**
 * `POST /public/v1/submit/remove_organization_feature`
 */
export type TRemoveOrganizationFeatureBody =
  operations["PublicApiService_RemoveOrganizationFeature"]["parameters"]["body"]["body"];

/**
 * Remove Organization Feature
 *
 * Removes an organization feature
 *
 * `POST /public/v1/submit/remove_organization_feature`
 */
export const removeOrganizationFeature = (
  input: TRemoveOrganizationFeatureInput
) =>
  request<
    TRemoveOrganizationFeatureResponse,
    TRemoveOrganizationFeatureBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/remove_organization_feature",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `RemoveOrganizationFeature` request, ready to be POSTed to Turnkey.
 *
 * See {@link RemoveOrganizationFeature}
 */
export const signRemoveOrganizationFeature = (
  input: TRemoveOrganizationFeatureInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TRemoveOrganizationFeatureBody, never, never>({
    uri: "/public/v1/submit/remove_organization_feature",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/set_organization_feature`
 */
export type TSetOrganizationFeatureResponse =
  operations["PublicApiService_SetOrganizationFeature"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/set_organization_feature`
 */
export type TSetOrganizationFeatureInput = {
  body: TSetOrganizationFeatureBody;
};

/**
 * `POST /public/v1/submit/set_organization_feature`
 */
export type TSetOrganizationFeatureBody =
  operations["PublicApiService_SetOrganizationFeature"]["parameters"]["body"]["body"];

/**
 * Set Organization Feature
 *
 * Sets an organization feature
 *
 * `POST /public/v1/submit/set_organization_feature`
 */
export const setOrganizationFeature = (input: TSetOrganizationFeatureInput) =>
  request<
    TSetOrganizationFeatureResponse,
    TSetOrganizationFeatureBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/set_organization_feature",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `SetOrganizationFeature` request, ready to be POSTed to Turnkey.
 *
 * See {@link SetOrganizationFeature}
 */
export const signSetOrganizationFeature = (
  input: TSetOrganizationFeatureInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TSetOrganizationFeatureBody, never, never>({
    uri: "/public/v1/submit/set_organization_feature",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/sign_raw_payload`
 */
export type TSignRawPayloadResponse =
  operations["PublicApiService_SignRawPayload"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/sign_raw_payload`
 */
export type TSignRawPayloadInput = { body: TSignRawPayloadBody };

/**
 * `POST /public/v1/submit/sign_raw_payload`
 */
export type TSignRawPayloadBody =
  operations["PublicApiService_SignRawPayload"]["parameters"]["body"]["body"];

/**
 * Sign Raw Payload
 *
 * Sign a raw payload
 *
 * `POST /public/v1/submit/sign_raw_payload`
 */
export const signRawPayload = (input: TSignRawPayloadInput) =>
  request<TSignRawPayloadResponse, TSignRawPayloadBody, never, never, never>({
    uri: "/public/v1/submit/sign_raw_payload",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `SignRawPayload` request, ready to be POSTed to Turnkey.
 *
 * See {@link SignRawPayload}
 */
export const signSignRawPayload = (
  input: TSignRawPayloadInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TSignRawPayloadBody, never, never>({
    uri: "/public/v1/submit/sign_raw_payload",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/sign_raw_payloads`
 */
export type TSignRawPayloadsResponse =
  operations["PublicApiService_SignRawPayloads"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/sign_raw_payloads`
 */
export type TSignRawPayloadsInput = { body: TSignRawPayloadsBody };

/**
 * `POST /public/v1/submit/sign_raw_payloads`
 */
export type TSignRawPayloadsBody =
  operations["PublicApiService_SignRawPayloads"]["parameters"]["body"]["body"];

/**
 * Sign Raw Payloads
 *
 * Sign multiple raw payloads with the same signing parameters
 *
 * `POST /public/v1/submit/sign_raw_payloads`
 */
export const signRawPayloads = (input: TSignRawPayloadsInput) =>
  request<TSignRawPayloadsResponse, TSignRawPayloadsBody, never, never, never>({
    uri: "/public/v1/submit/sign_raw_payloads",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `SignRawPayloads` request, ready to be POSTed to Turnkey.
 *
 * See {@link SignRawPayloads}
 */
export const signSignRawPayloads = (
  input: TSignRawPayloadsInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TSignRawPayloadsBody, never, never>({
    uri: "/public/v1/submit/sign_raw_payloads",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/sign_transaction`
 */
export type TSignTransactionResponse =
  operations["PublicApiService_SignTransaction"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/sign_transaction`
 */
export type TSignTransactionInput = { body: TSignTransactionBody };

/**
 * `POST /public/v1/submit/sign_transaction`
 */
export type TSignTransactionBody =
  operations["PublicApiService_SignTransaction"]["parameters"]["body"]["body"];

/**
 * Sign Transaction
 *
 * Sign a transaction
 *
 * `POST /public/v1/submit/sign_transaction`
 */
export const signTransaction = (input: TSignTransactionInput) =>
  request<TSignTransactionResponse, TSignTransactionBody, never, never, never>({
    uri: "/public/v1/submit/sign_transaction",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `SignTransaction` request, ready to be POSTed to Turnkey.
 *
 * See {@link SignTransaction}
 */
export const signSignTransaction = (
  input: TSignTransactionInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TSignTransactionBody, never, never>({
    uri: "/public/v1/submit/sign_transaction",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/update_policy`
 */
export type TUpdatePolicyResponse =
  operations["PublicApiService_UpdatePolicy"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/update_policy`
 */
export type TUpdatePolicyInput = { body: TUpdatePolicyBody };

/**
 * `POST /public/v1/submit/update_policy`
 */
export type TUpdatePolicyBody =
  operations["PublicApiService_UpdatePolicy"]["parameters"]["body"]["body"];

/**
 * Update Policy
 *
 * Update an existing Policy
 *
 * `POST /public/v1/submit/update_policy`
 */
export const updatePolicy = (input: TUpdatePolicyInput) =>
  request<TUpdatePolicyResponse, TUpdatePolicyBody, never, never, never>({
    uri: "/public/v1/submit/update_policy",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `UpdatePolicy` request, ready to be POSTed to Turnkey.
 *
 * See {@link UpdatePolicy}
 */
export const signUpdatePolicy = (
  input: TUpdatePolicyInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TUpdatePolicyBody, never, never>({
    uri: "/public/v1/submit/update_policy",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/update_private_key_tag`
 */
export type TUpdatePrivateKeyTagResponse =
  operations["PublicApiService_UpdatePrivateKeyTag"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/update_private_key_tag`
 */
export type TUpdatePrivateKeyTagInput = { body: TUpdatePrivateKeyTagBody };

/**
 * `POST /public/v1/submit/update_private_key_tag`
 */
export type TUpdatePrivateKeyTagBody =
  operations["PublicApiService_UpdatePrivateKeyTag"]["parameters"]["body"]["body"];

/**
 * Update Private Key Tag
 *
 * Update human-readable name or associated private keys. Note that this activity is atomic: all of the updates will succeed at once, or all of them will fail.
 *
 * `POST /public/v1/submit/update_private_key_tag`
 */
export const updatePrivateKeyTag = (input: TUpdatePrivateKeyTagInput) =>
  request<
    TUpdatePrivateKeyTagResponse,
    TUpdatePrivateKeyTagBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/update_private_key_tag",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `UpdatePrivateKeyTag` request, ready to be POSTed to Turnkey.
 *
 * See {@link UpdatePrivateKeyTag}
 */
export const signUpdatePrivateKeyTag = (
  input: TUpdatePrivateKeyTagInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TUpdatePrivateKeyTagBody, never, never>({
    uri: "/public/v1/submit/update_private_key_tag",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/update_root_quorum`
 */
export type TUpdateRootQuorumResponse =
  operations["PublicApiService_UpdateRootQuorum"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/update_root_quorum`
 */
export type TUpdateRootQuorumInput = { body: TUpdateRootQuorumBody };

/**
 * `POST /public/v1/submit/update_root_quorum`
 */
export type TUpdateRootQuorumBody =
  operations["PublicApiService_UpdateRootQuorum"]["parameters"]["body"]["body"];

/**
 * Update Root Quorum
 *
 * Set the threshold and members of the root quorum. This must be approved by the current root quorum.
 *
 * `POST /public/v1/submit/update_root_quorum`
 */
export const updateRootQuorum = (input: TUpdateRootQuorumInput) =>
  request<
    TUpdateRootQuorumResponse,
    TUpdateRootQuorumBody,
    never,
    never,
    never
  >({
    uri: "/public/v1/submit/update_root_quorum",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `UpdateRootQuorum` request, ready to be POSTed to Turnkey.
 *
 * See {@link UpdateRootQuorum}
 */
export const signUpdateRootQuorum = (
  input: TUpdateRootQuorumInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TUpdateRootQuorumBody, never, never>({
    uri: "/public/v1/submit/update_root_quorum",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/update_user`
 */
export type TUpdateUserResponse =
  operations["PublicApiService_UpdateUser"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/update_user`
 */
export type TUpdateUserInput = { body: TUpdateUserBody };

/**
 * `POST /public/v1/submit/update_user`
 */
export type TUpdateUserBody =
  operations["PublicApiService_UpdateUser"]["parameters"]["body"]["body"];

/**
 * Update User
 *
 * Update a User in an existing Organization
 *
 * `POST /public/v1/submit/update_user`
 */
export const updateUser = (input: TUpdateUserInput) =>
  request<TUpdateUserResponse, TUpdateUserBody, never, never, never>({
    uri: "/public/v1/submit/update_user",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `UpdateUser` request, ready to be POSTed to Turnkey.
 *
 * See {@link UpdateUser}
 */
export const signUpdateUser = (
  input: TUpdateUserInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TUpdateUserBody, never, never>({
    uri: "/public/v1/submit/update_user",
    body: input.body,
    options,
  });

/**
 * `POST /public/v1/submit/update_user_tag`
 */
export type TUpdateUserTagResponse =
  operations["PublicApiService_UpdateUserTag"]["responses"]["200"]["schema"];

/**
 * `POST /public/v1/submit/update_user_tag`
 */
export type TUpdateUserTagInput = { body: TUpdateUserTagBody };

/**
 * `POST /public/v1/submit/update_user_tag`
 */
export type TUpdateUserTagBody =
  operations["PublicApiService_UpdateUserTag"]["parameters"]["body"]["body"];

/**
 * Update User Tag
 *
 * Update human-readable name or associated users. Note that this activity is atomic: all of the updates will succeed at once, or all of them will fail.
 *
 * `POST /public/v1/submit/update_user_tag`
 */
export const updateUserTag = (input: TUpdateUserTagInput) =>
  request<TUpdateUserTagResponse, TUpdateUserTagBody, never, never, never>({
    uri: "/public/v1/submit/update_user_tag",
    method: "POST",
    body: input.body,
  });

/**
 * Request a WebAuthn assertion and return a signed `UpdateUserTag` request, ready to be POSTed to Turnkey.
 *
 * See {@link UpdateUserTag}
 */
export const signUpdateUserTag = (
  input: TUpdateUserTagInput,
  options?: TurnkeyCredentialRequestOptions
) =>
  signedRequest<TUpdateUserTagBody, never, never>({
    uri: "/public/v1/submit/update_user_tag",
    body: input.body,
    options,
  });

/**
 * `POST /tkhq/api/v1/noop-codegen-anchor`
 */
export type TNOOPCodegenAnchorResponse =
  operations["PublicApiService_NOOPCodegenAnchor"]["responses"]["200"]["schema"];

/**
 * `POST /tkhq/api/v1/noop-codegen-anchor`
 */
export const nOOPCodegenAnchor = () =>
  request<TNOOPCodegenAnchorResponse, never, never, never, never>({
    uri: "/tkhq/api/v1/noop-codegen-anchor",
    method: "POST",
  });

/**
 * Request a WebAuthn assertion and return a signed `NOOPCodegenAnchor` request, ready to be POSTed to Turnkey.
 *
 * See {@link NOOPCodegenAnchor}
 */
export const signNOOPCodegenAnchor = () =>
  signedRequest<never, never, never>({
    uri: "/tkhq/api/v1/noop-codegen-anchor",
  });