@zitadel/api 0.0.0

package/dist/generated/endpoints/zitadelNextGen.mjs

@@ -0,0 +1,959 @@
+import { t as __exportAll } from "../../chunk-CfYAbeIz.mjs";
+import { getProxyPath } from "../../runtime/base-url.mjs";
+import { customFetch } from "../../runtime/fetch.mjs";
+//#region src/generated/endpoints/zitadelNextGen.ts
+/**
+* Generated by orval v8.10.0 🍺
+* Do not edit manually.
+* Zitadel NextGen
+* This is the next generation of the Zitadel identity platform.
+* OpenAPI spec version: 0.0.1
+*/
+var zitadelNextGen_exports = /* @__PURE__ */ __exportAll({
+	authorizeDevice: () => authorizeDevice,
+	authorizeGet: () => authorizeGet,
+	createAuthAttempt: () => createAuthAttempt,
+	createFlow: () => createFlow,
+	createFlowDefinition: () => createFlowDefinition,
+	createHandoff: () => createHandoff,
+	createProject: () => createProject,
+	createSchema: () => createSchema,
+	createSession: () => createSession,
+	createTeam: () => createTeam,
+	createUser: () => createUser,
+	deleteFlowDefinition: () => deleteFlowDefinition,
+	endSession: () => endSession,
+	exchangeHandoff: () => exchangeHandoff,
+	getAuthAttempt: () => getAuthAttempt,
+	getAuthorizeDeviceUrl: () => getAuthorizeDeviceUrl,
+	getAuthorizeGetUrl: () => getAuthorizeGetUrl,
+	getCreateAuthAttemptUrl: () => getCreateAuthAttemptUrl,
+	getCreateFlowDefinitionUrl: () => getCreateFlowDefinitionUrl,
+	getCreateFlowUrl: () => getCreateFlowUrl,
+	getCreateHandoffUrl: () => getCreateHandoffUrl,
+	getCreateProjectUrl: () => getCreateProjectUrl,
+	getCreateSchemaUrl: () => getCreateSchemaUrl,
+	getCreateSessionUrl: () => getCreateSessionUrl,
+	getCreateTeamUrl: () => getCreateTeamUrl,
+	getCreateUserUrl: () => getCreateUserUrl,
+	getDeleteFlowDefinitionUrl: () => getDeleteFlowDefinitionUrl,
+	getEndSessionUrl: () => getEndSessionUrl,
+	getExchangeHandoffUrl: () => getExchangeHandoffUrl,
+	getFlowDefinition: () => getFlowDefinition,
+	getFlowStep: () => getFlowStep,
+	getGetAuthAttemptUrl: () => getGetAuthAttemptUrl,
+	getGetFlowDefinitionUrl: () => getGetFlowDefinitionUrl,
+	getGetFlowStepUrl: () => getGetFlowStepUrl,
+	getGetHealthUrl: () => getGetHealthUrl,
+	getGetKeysUrl: () => getGetKeysUrl,
+	getGetLiveUrl: () => getGetLiveUrl,
+	getGetMySessionUrl: () => getGetMySessionUrl,
+	getGetOpenIDConfigurationUrl: () => getGetOpenIDConfigurationUrl,
+	getGetProjectUrl: () => getGetProjectUrl,
+	getGetReadyUrl: () => getGetReadyUrl,
+	getGetSchemaByIdUrl: () => getGetSchemaByIdUrl,
+	getGetSessionUrl: () => getGetSessionUrl,
+	getGetTeamUrl: () => getGetTeamUrl,
+	getGetTokenUrl: () => getGetTokenUrl,
+	getGetUserByIDUrl: () => getGetUserByIDUrl,
+	getGetUserInfoUrl: () => getGetUserInfoUrl,
+	getHealth: () => getHealth,
+	getIntrospectUrl: () => getIntrospectUrl,
+	getIssueChallengeUrl: () => getIssueChallengeUrl,
+	getKeys: () => getKeys,
+	getListFlowDefinitionsUrl: () => getListFlowDefinitionsUrl,
+	getListSessionsUrl: () => getListSessionsUrl,
+	getListUsersUrl: () => getListUsersUrl,
+	getLive: () => getLive,
+	getMySession: () => getMySession,
+	getOpenIDConfiguration: () => getOpenIDConfiguration,
+	getProject: () => getProject,
+	getReady: () => getReady,
+	getRevokeMySessionUrl: () => getRevokeMySessionUrl,
+	getRevokeSessionUrl: () => getRevokeSessionUrl,
+	getRevokeTokenUrl: () => getRevokeTokenUrl,
+	getSchemaById: () => getSchemaById,
+	getSession: () => getSession,
+	getSubmitFlowEventUrl: () => getSubmitFlowEventUrl,
+	getSubmitFlowStepUrl: () => getSubmitFlowStepUrl,
+	getTeam: () => getTeam,
+	getToken: () => getToken,
+	getUpdateFlowDefinitionUrl: () => getUpdateFlowDefinitionUrl,
+	getUserByID: () => getUserByID,
+	getUserInfo: () => getUserInfo,
+	getVerifyChallengeProofUrl: () => getVerifyChallengeProofUrl,
+	introspect: () => introspect,
+	issueChallenge: () => issueChallenge,
+	listFlowDefinitions: () => listFlowDefinitions,
+	listSessions: () => listSessions,
+	listUsers: () => listUsers,
+	revokeMySession: () => revokeMySession,
+	revokeSession: () => revokeSession,
+	revokeToken: () => revokeToken,
+	submitFlowEvent: () => submitFlowEvent,
+	submitFlowStep: () => submitFlowStep,
+	updateFlowDefinition: () => updateFlowDefinition,
+	verifyChallengeProof: () => verifyChallengeProof
+});
+const getGetOpenIDConfigurationUrl = () => {
+	return `${getProxyPath()}/.well-known/openid-configuration`;
+};
+/**
+* Retrieve the OpenID Connect configuration
+* @summary Get OpenID Connect configuration
+*/
+const getOpenIDConfiguration = async (options) => {
+	return customFetch(getGetOpenIDConfigurationUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getAuthorizeGetUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/auth/authorize?${stringifiedParams}` : `${getProxyPath()}/auth/authorize`;
+};
+/**
+* @summary Authorize a user
+*/
+const authorizeGet = async (params, options) => {
+	return customFetch(getAuthorizeGetUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getAuthorizeDeviceUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/auth/device-authorization?${stringifiedParams}` : `${getProxyPath()}/auth/device-authorization`;
+};
+/**
+* @summary Authorize a device
+*/
+const authorizeDevice = async (params, options) => {
+	return customFetch(getAuthorizeDeviceUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getEndSessionUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/auth/end-session?${stringifiedParams}` : `${getProxyPath()}/auth/end-session`;
+};
+/**
+* @summary End a session
+*/
+const endSession = async (params, options) => {
+	return customFetch(getEndSessionUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getIntrospectUrl = () => {
+	return `${getProxyPath()}/auth/introspect`;
+};
+/**
+* @summary Introspect a token
+*/
+const introspect = async (introspectBody, options) => {
+	const formUrlEncoded = new URLSearchParams();
+	formUrlEncoded.append(`token`, introspectBody.token);
+	if (introspectBody.token_type_hint !== void 0) formUrlEncoded.append(`token_type_hint`, introspectBody.token_type_hint);
+	return customFetch(getIntrospectUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			...options?.headers
+		},
+		body: formUrlEncoded
+	});
+};
+const getGetKeysUrl = () => {
+	return `${getProxyPath()}/auth/keys`;
+};
+/**
+* @summary Get public keys
+*/
+const getKeys = async (options) => {
+	return customFetch(getGetKeysUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getRevokeTokenUrl = () => {
+	return `${getProxyPath()}/auth/revoke`;
+};
+/**
+* @summary Revoke an access token or refresh token
+*/
+const revokeToken = async (revokeTokenBody, options) => {
+	const formUrlEncoded = new URLSearchParams();
+	if (revokeTokenBody.token !== void 0) formUrlEncoded.append(`token`, revokeTokenBody.token);
+	if (revokeTokenBody.token_type_hint !== void 0) formUrlEncoded.append(`token_type_hint`, revokeTokenBody.token_type_hint);
+	return customFetch(getRevokeTokenUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			...options?.headers
+		},
+		body: formUrlEncoded
+	});
+};
+const getGetTokenUrl = () => {
+	return `${getProxyPath()}/auth/token`;
+};
+/**
+* @summary Get accesstoken
+*/
+const getToken = async (getTokenBody, options) => {
+	const formUrlEncoded = new URLSearchParams();
+	if (getTokenBody.code !== void 0) formUrlEncoded.append(`code`, getTokenBody.code);
+	if (getTokenBody.client_assertion !== void 0) formUrlEncoded.append(`client_assertion`, getTokenBody.client_assertion);
+	if (getTokenBody.client_assertion_type !== void 0) formUrlEncoded.append(`client_assertion_type`, getTokenBody.client_assertion_type);
+	if (getTokenBody.client_id !== void 0) formUrlEncoded.append(`client_id`, getTokenBody.client_id);
+	if (getTokenBody.client_secret !== void 0) formUrlEncoded.append(`client_secret`, getTokenBody.client_secret);
+	if (getTokenBody.code_verifier !== void 0) formUrlEncoded.append(`code_verifier`, getTokenBody.code_verifier);
+	if (getTokenBody.grant_type !== void 0) formUrlEncoded.append(`grant_type`, getTokenBody.grant_type);
+	if (getTokenBody.redirect_uri !== void 0) formUrlEncoded.append(`redirect_uri`, getTokenBody.redirect_uri);
+	return customFetch(getGetTokenUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			...options?.headers
+		},
+		body: formUrlEncoded
+	});
+};
+const getGetUserInfoUrl = () => {
+	return `${getProxyPath()}/auth/userinfo`;
+};
+/**
+* @summary Get user info
+*/
+const getUserInfo = async (options) => {
+	return customFetch(getGetUserInfoUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetHealthUrl = () => {
+	return `${getProxyPath()}/healthz`;
+};
+/**
+* Check whether the server is healthy
+* @summary Check server health
+*/
+const getHealth = async (options) => {
+	return customFetch(getGetHealthUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetLiveUrl = () => {
+	return `${getProxyPath()}/livez`;
+};
+/**
+* Check whether the server is started
+* @summary Check server liveness
+*/
+const getLive = async (options) => {
+	return customFetch(getGetLiveUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetReadyUrl = () => {
+	return `${getProxyPath()}/readyz`;
+};
+/**
+* Check whether the server is ready to accept requests
+* @summary Check server readiness
+*/
+const getReady = async (options) => {
+	return customFetch(getGetReadyUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getCreateUserUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/user?${stringifiedParams}` : `${getProxyPath()}/user`;
+};
+/**
+* @summary Create user
+*/
+const createUser = async (createUserBody, params, options) => {
+	return customFetch(getCreateUserUrl(params), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createUserBody)
+	});
+};
+const getListUsersUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/user?${stringifiedParams}` : `${getProxyPath()}/user`;
+};
+/**
+* @summary List users
+*/
+const listUsers = async (params, options) => {
+	return customFetch(getListUsersUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetUserByIDUrl = (userId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/user/${userId}?${stringifiedParams}` : `${getProxyPath()}/user/${userId}`;
+};
+/**
+* @summary Get user by ID
+*/
+const getUserByID = async (userId, params, options) => {
+	return customFetch(getGetUserByIDUrl(userId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getCreateFlowUrl = () => {
+	return `${getProxyPath()}/flow`;
+};
+/**
+* Resolves a flow definition based on purpose + audience context and returns
+the first capability step. Creates a new session implicitly unless
+`session_id` is provided (for step-up / reauth on an existing session).
+
+The response contains an `id` field — the flow handle. Use it as the path
+parameter for all subsequent `/flow/{id}/submit` and `/flow/{id}/event` calls.
+
+The response also sets an encrypted `HttpOnly` cookie (`_zflow`) containing
+the flow's orchestration state (current step, collected data, history).
+The server is stateless between requests — all flow state lives in this
+cookie. The browser sends it automatically on subsequent requests.
+
+* @summary Start a new flow
+*/
+const createFlow = async (createFlowBody, options) => {
+	return customFetch(getCreateFlowUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createFlowBody)
+	});
+};
+const getGetFlowStepUrl = (id) => {
+	return `${getProxyPath()}/flow/${id}`;
+};
+/**
+* Returns the current capability step without advancing the state machine.
+Useful for page reloads or re-rendering after a network error.
+
+* @summary Get current step (re-render)
+*/
+const getFlowStep = async (id, options) => {
+	return customFetch(getGetFlowStepUrl(id), {
+		...options,
+		method: "GET"
+	});
+};
+const getSubmitFlowStepUrl = (id) => {
+	return `${getProxyPath()}/flow/${id}/submit`;
+};
+/**
+* Submits user input for the current step. The server validates,
+processes (e.g., verifies a credential), advances the state machine
+through any invisible steps, and returns the next visible step.
+
+The response sets an updated encrypted `HttpOnly` cookie (`_zflow`)
+with the new flow state. The server is stateless — all orchestration
+state is carried in this cookie between requests.
+
+**Important:** The `id` in the response may differ from the `id` used in
+the request. This happens when a flow pivots (pushes a new flow onto the
+stack) or when a stacked flow completes (auto-pops to the parent flow).
+Always use the `id` from the latest response for the next request.
+
+## Flow completion
+
+When `step.type` is `complete`, the flow is terminal. The `step.behavior`
+field tells the frontend what to do:
+
+| `behavior`   | Action                                                     |
+|------------- |------------------------------------------------------------|
+| `redirect`   | Navigate to `redirect_uri` (OIDC/SAML auth request done). |
+| `show`       | Render the step as a success screen (e.g., registration).  |
+
+A `complete` step is only returned when the **entire flow stack** is done.
+If a stacked flow (e.g., recovery pivoted from login) finishes, the server
+auto-pops to the parent flow and returns the parent's next step — the
+frontend never sees a `complete` for intermediate flows.
+
+* @summary Submit step data and advance
+*/
+const submitFlowStep = async (id, submitFlowStepBody, options) => {
+	return customFetch(getSubmitFlowStepUrl(id), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(submitFlowStepBody)
+	});
+};
+const getSubmitFlowEventUrl = (id) => {
+	return `${getProxyPath()}/flow/${id}/event`;
+};
+/**
+* Submits telemetry or fingerprint data from the frontend.
+Does not advance the state machine. Used for risk evaluation.
+
+* @summary Submit client-side event
+*/
+const submitFlowEvent = async (id, submitFlowEventBody, options) => {
+	return customFetch(getSubmitFlowEventUrl(id), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(submitFlowEventBody)
+	});
+};
+const getCreateAuthAttemptUrl = () => {
+	return `${getProxyPath()}/auth_attempts`;
+};
+/**
+* Starts a new authentication attempt. This is the entry point for the auth_attempts state machine.
+
+An attempt is an ephemeral (15-minute TTL) state machine that drives a single authentication round.
+It accepts factor challenges, verifies proofs, and completes into a session or handoff token.
+
+Accepts a project_id and challenge_nonce (from POST /bootstrap/challenge). For step-up re-auth,
+also include session_id to add factors to an existing session.
+
+* @summary Create a new authentication attempt
+*/
+const createAuthAttempt = async (createAuthAttemptBody, options) => {
+	return customFetch(getCreateAuthAttemptUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createAuthAttemptBody)
+	});
+};
+const getGetAuthAttemptUrl = (attemptId) => {
+	return `${getProxyPath()}/auth_attempts/${attemptId}`;
+};
+/**
+* Polls the current state of an authentication attempt.
+
+Returns the attempt's state, available factors for the next challenge,
+challenges issued so far, and any errors preventing progress.
+
+Use this for polling during long-running factor verifications (e.g., waiting for
+a federated IdP callback or a device flow).
+
+* @summary Get authentication attempt state
+*/
+const getAuthAttempt = async (attemptId, options) => {
+	return customFetch(getGetAuthAttemptUrl(attemptId), {
+		...options,
+		method: "GET"
+	});
+};
+const getIssueChallengeUrl = (attemptId) => {
+	return `${getProxyPath()}/auth_attempts/${attemptId}/challenges`;
+};
+/**
+* Issues a single-factor verification challenge within an auth attempt.
+
+This advances the authentication state machine by requesting a specific factor method
+(password, passkey, TOTP, OTP via SMS, etc.). The server responds with challenge details
+including method, metadata, and any UI hints. The client then verifies the proof
+by calling POST /auth_attempts/{attempt_id}/challenges/{challenge_id}/verify.
+
+* @summary Issue a factor challenge
+*/
+const issueChallenge = async (attemptId, issueChallengeBody, options) => {
+	return customFetch(getIssueChallengeUrl(attemptId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(issueChallengeBody)
+	});
+};
+const getVerifyChallengeProofUrl = (attemptId, challengeId) => {
+	return `${getProxyPath()}/auth_attempts/${attemptId}/challenges/${challengeId}/verify`;
+};
+/**
+* Submits a proof (credential, code, assertion) to verify a factor challenge.
+
+The proof format depends on the challenge method. For example:
+- `password` method: { password: "…" }
+- `totp` method: { totp: { code: "123456" } }
+- `passkey` method: { passkey: { assertion: "…" } }
+- `recovery_code` method: { recovery_code: "…" }
+
+On successful verification, the factor is written to the auth attempt.
+The attempt moves to the next pending challenge or completes if all required factors are verified.
+
+* @summary Verify a factor proof
+*/
+const verifyChallengeProof = async (attemptId, challengeId, verifyChallengeProofBody, options) => {
+	return customFetch(getVerifyChallengeProofUrl(attemptId, challengeId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(verifyChallengeProofBody)
+	});
+};
+const getCreateHandoffUrl = (attemptId) => {
+	return `${getProxyPath()}/auth_attempts/${attemptId}/handoff`;
+};
+/**
+* Completes the authentication attempt and mints a `handoff_token`.
+
+Call this after all required factors have been verified and the attempt is in `completed` state.
+The handoff token is short-lived (≤60 seconds) and must be exchanged at
+POST /sessions/exchange to receive the final session and session_token.
+
+The handoff token is:
+- Single-use (atomic exchange, no retry)
+- Audience-bound (requires matching project key for exchange)
+- Idempotency-safe within a 5-minute window (see conventions)
+
+* @summary Complete authentication and create handoff token
+*/
+const createHandoff = async (attemptId, options) => {
+	return customFetch(getCreateHandoffUrl(attemptId), {
+		...options,
+		method: "POST"
+	});
+};
+const getCreateProjectUrl = () => {
+	return `${getProxyPath()}/projects`;
+};
+/**
+* @summary Create project
+*/
+const createProject = async (createProjectBody, options) => {
+	return customFetch(getCreateProjectUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createProjectBody)
+	});
+};
+const getGetProjectUrl = (projectId) => {
+	return `${getProxyPath()}/projects/${projectId}`;
+};
+/**
+* Returns the current state of a project.
+
+* @summary Get project
+*/
+const getProject = async (projectId, options) => {
+	return customFetch(getGetProjectUrl(projectId), {
+		...options,
+		method: "GET"
+	});
+};
+const getCreateSessionUrl = () => {
+	return `${getProxyPath()}/sessions`;
+};
+/**
+* Creates an anonymous session shell with no user and no factors (`state: building`).
+
+This is optional — an `auth_attempt` will create a session implicitly if none is provided.
+Use this explicitly when you want to:
+- Pre-allocate a `session_id` before the user is known, so device/telemetry signals
+can be correlated with the eventual authenticated session from the start.
+- Track anonymous state (bot detection, device fingerprint) that survives until authentication.
+
+The returned `session_token` authorises GET and DELETE on this session.
+It is superseded when a handoff exchange completes — clients must replace it at that point.
+
+Anonymous sessions expire aggressively (10-minute TTL). The TTL resets to the configured
+full session TTL when the first authentication factor is written via a completing `auth_attempt`.
+
+* @summary Create an anonymous session shell
+*/
+const createSession = async (createSessionBody, options) => {
+	return customFetch(getCreateSessionUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createSessionBody)
+	});
+};
+const getListSessionsUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/sessions?${stringifiedParams}` : `${getProxyPath()}/sessions`;
+};
+/**
+* Returns a paginated list of sessions for a project.
+Requires a project service key (OAuth2 client credentials).
+
+* @summary List sessions
+*/
+const listSessions = async (params, options) => {
+	return customFetch(getListSessionsUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getExchangeHandoffUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/sessions/exchange?${stringifiedParams}` : `${getProxyPath()}/sessions/exchange`;
+};
+/**
+* Consumes a one-time `handoff_token` minted by `POST /auth_attempts/{id}/handoff`
+and returns the resulting session and a `session_token`.
+
+The server resolves the originating `auth_attempt` from the token and then:
+
+| Originating auth_attempt | Outcome |
+|---|---|
+| No `session_id` | A new authenticated session is **created**. |
+| `session_id` points to an anonymous shell | Existing session is **upgraded** — user and factors written in, TTL reset to full session TTL. |
+| `session_id` points to an active session (step-up) | Existing session is **upgraded** — new factors merged, `assurance_levels[]` expanded. |
+
+The response shape is identical in all three cases.
+
+The `session_token` supersedes any previously issued `session_token` for the same session.
+Clients must replace their stored token at this point.
+
+Requires a project service key (OAuth2 client credentials).
+
+* @summary Exchange handoff token for a session
+*/
+const exchangeHandoff = async (exchangeHandoffBody, params, options) => {
+	return customFetch(getExchangeHandoffUrl(params), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(exchangeHandoffBody)
+	});
+};
+const getGetSessionUrl = (sessionId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/sessions/${sessionId}?${stringifiedParams}` : `${getProxyPath()}/sessions/${sessionId}`;
+};
+/**
+* Returns the current state of a session including its factors and all currently
+satisfied assurance levels.
+
+`assurance_levels[]` may shrink over time as factor freshness windows expire,
+without the session itself expiring. Use step-up authentication (a new `auth_attempt`
+against the same `session_id`) to restore a dropped assurance level.
+
+* @summary Get session state
+*/
+const getSession = async (sessionId, params, options) => {
+	return customFetch(getGetSessionUrl(sessionId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getRevokeSessionUrl = (sessionId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/sessions/${sessionId}?${stringifiedParams}` : `${getProxyPath()}/sessions/${sessionId}`;
+};
+/**
+* Revokes the session immediately (`state: revoked`). This is the logout operation.
+
+The session_token issued at creation (or superseded by a handoff exchange) is required.
+After revocation, any tokens derived from this session are invalidated.
+
+* @summary Revoke session
+*/
+const revokeSession = async (sessionId, params, options) => {
+	return customFetch(getRevokeSessionUrl(sessionId, params), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getGetMySessionUrl = () => {
+	return `${getProxyPath()}/sessions/me`;
+};
+/**
+* Returns the current state of the current session including its factors and all currently
+satisfied assurance levels.
+
+`assurance_levels[]` may shrink over time as factor freshness windows expire,
+without the session itself expiring. Use step-up authentication (a new `auth_attempt`
+against the same `session_id`) to restore a dropped assurance level.
+
+* @summary Get my session state
+*/
+const getMySession = async (options) => {
+	return customFetch(getGetMySessionUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getRevokeMySessionUrl = () => {
+	return `${getProxyPath()}/sessions/me`;
+};
+/**
+* Revokes the session immediately (`state: revoked`). This is the logout operation.
+
+The __nextgen_session cookie issued at creation (or superseded by a handoff exchange) is required.
+After revocation, any tokens derived from this session are invalidated including the cookie itself, which is cleared in the response.
+
+* @summary Revoke my session
+*/
+const revokeMySession = async (options) => {
+	return customFetch(getRevokeMySessionUrl(), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getCreateSchemaUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/schemas?${stringifiedParams}` : `${getProxyPath()}/schemas`;
+};
+/**
+* Create a new schema. The schema definition must include a unique $id field,
+which will be used to identify the schema in future requests. The $id must
+be a valid URI and should ideally point to the location where the schema
+can be accessed.
+
+The schema can either be a concrete schema, e.g. a user schema, or a
+schema-url which will be resolved by the server.
+
+* @summary Create new schema
+*/
+const createSchema = async (createSchemaBody, params, options) => {
+	return customFetch(getCreateSchemaUrl(params), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createSchemaBody)
+	});
+};
+const getGetSchemaByIdUrl = (id, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/schemas/${id}?${stringifiedParams}` : `${getProxyPath()}/schemas/${id}`;
+};
+/**
+* Get a schema by its ID. This will return the default revision of the schema.
+* @summary Get schema by ID
+*/
+const getSchemaById = async (id, params, options) => {
+	return customFetch(getGetSchemaByIdUrl(id, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getCreateFlowDefinitionUrl = () => {
+	return `${getProxyPath()}/flow_definitions`;
+};
+/**
+* Creates a new flow definition.
+Flow definitions are templates that define the sequence of steps (capabilities)
+for a particular user journey (e.g., registration, login, password reset).
+
+Flow definitions are created based on the flow meta schema, which includes the flow's purpose, audience, and the steps involved.
+
+* @summary Create a new flow definition
+*/
+const createFlowDefinition = async (createFlowDefinitionBody, options) => {
+	return customFetch(getCreateFlowDefinitionUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createFlowDefinitionBody)
+	});
+};
+const getListFlowDefinitionsUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/flow_definitions?${stringifiedParams}` : `${getProxyPath()}/flow_definitions`;
+};
+/**
+* Retrieves a list of all flow definitions.
+This endpoint can be used to view existing flow definitions and their configurations.
+
+* @summary List flow definitions
+*/
+const listFlowDefinitions = async (params, options) => {
+	return customFetch(getListFlowDefinitionsUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetFlowDefinitionUrl = (id) => {
+	return `${getProxyPath()}/flow_definitions/${id}`;
+};
+/**
+* Get a flow definition by id
+* @summary Get a flow definition by id
+*/
+const getFlowDefinition = async (id, options) => {
+	return customFetch(getGetFlowDefinitionUrl(id), {
+		...options,
+		method: "GET"
+	});
+};
+const getUpdateFlowDefinitionUrl = (id) => {
+	return `${getProxyPath()}/flow_definitions/${id}`;
+};
+/**
+* Update a flow definition by id
+* @summary Update a flow definition by id
+*/
+const updateFlowDefinition = async (id, updateFlowDefinitionBody, options) => {
+	return customFetch(getUpdateFlowDefinitionUrl(id), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updateFlowDefinitionBody)
+	});
+};
+const getDeleteFlowDefinitionUrl = (id) => {
+	return `${getProxyPath()}/flow_definitions/${id}`;
+};
+/**
+* Delete a flow definition by id
+* @summary Delete a flow definition by id
+*/
+const deleteFlowDefinition = async (id, options) => {
+	return customFetch(getDeleteFlowDefinitionUrl(id), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getCreateTeamUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/teams?${stringifiedParams}` : `${getProxyPath()}/teams`;
+};
+/**
+* @summary Create team
+*/
+const createTeam = async (params, createTeamBody, options) => {
+	return customFetch(getCreateTeamUrl(params), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createTeamBody)
+	});
+};
+const getGetTeamUrl = (teamId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `${getProxyPath()}/teams/${teamId}?${stringifiedParams}` : `${getProxyPath()}/teams/${teamId}`;
+};
+/**
+* Returns the current state of a team.
+
+* @summary Get team
+*/
+const getTeam = async (teamId, params, options) => {
+	return customFetch(getGetTeamUrl(teamId, params), {
+		...options,
+		method: "GET"
+	});
+};
+//#endregion
+export { authorizeDevice, authorizeGet, createAuthAttempt, createFlow, createFlowDefinition, createHandoff, createProject, createSchema, createSession, createTeam, createUser, deleteFlowDefinition, endSession, exchangeHandoff, getAuthAttempt, getAuthorizeDeviceUrl, getAuthorizeGetUrl, getCreateAuthAttemptUrl, getCreateFlowDefinitionUrl, getCreateFlowUrl, getCreateHandoffUrl, getCreateProjectUrl, getCreateSchemaUrl, getCreateSessionUrl, getCreateTeamUrl, getCreateUserUrl, getDeleteFlowDefinitionUrl, getEndSessionUrl, getExchangeHandoffUrl, getFlowDefinition, getFlowStep, getGetAuthAttemptUrl, getGetFlowDefinitionUrl, getGetFlowStepUrl, getGetHealthUrl, getGetKeysUrl, getGetLiveUrl, getGetMySessionUrl, getGetOpenIDConfigurationUrl, getGetProjectUrl, getGetReadyUrl, getGetSchemaByIdUrl, getGetSessionUrl, getGetTeamUrl, getGetTokenUrl, getGetUserByIDUrl, getGetUserInfoUrl, getHealth, getIntrospectUrl, getIssueChallengeUrl, getKeys, getListFlowDefinitionsUrl, getListSessionsUrl, getListUsersUrl, getLive, getMySession, getOpenIDConfiguration, getProject, getReady, getRevokeMySessionUrl, getRevokeSessionUrl, getRevokeTokenUrl, getSchemaById, getSession, getSubmitFlowEventUrl, getSubmitFlowStepUrl, getTeam, getToken, getUpdateFlowDefinitionUrl, getUserByID, getUserInfo, getVerifyChallengeProofUrl, introspect, issueChallenge, listFlowDefinitions, listSessions, listUsers, revokeMySession, revokeSession, revokeToken, submitFlowEvent, submitFlowStep, zitadelNextGen_exports as t, updateFlowDefinition, verifyChallengeProof };
+
+//# sourceMappingURL=zitadelNextGen.mjs.map