@zitadel/api 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/generated/endpoints/zitadelNextGen.msw.ts

@@ -10,9 +10,9 @@ import { HttpResponse, http } from "msw";
 import type { RequestHandlerOptions } from "msw";
 
 import type {
-  AuthorizeDevice200,
-  AuthorizeGetDefault,
+  CompleteClaim200,
   CreateAuthAttempt201,
+  CreateBranding201,
   CreateFlow201,
   CreateFlowDefinition201,
   CreateHandoff200,
@@ -23,396 +23,157 @@ import type {
   CreateUser201,
   ExchangeHandoff200,
   GetAuthAttempt200,
+  GetBrandingById200,
+  GetClaimStatus200,
   GetFlowDefinition200,
   GetFlowStep200,
   GetHealthDefault,
-  GetKeys200,
   GetLiveDefault,
   GetMySession200,
   GetMyUser200,
-  GetOpenIDConfiguration200,
   GetProject200,
   GetReadyDefault,
   GetSchemaById200,
   GetSession200,
   GetTeam200,
-  GetToken200,
   GetUserByID200,
-  GetUserInfo200,
-  Introspect200,
+  InitClaim201,
   IssueChallenge201,
+  ListBranding200Item,
   ListFlowDefinitions200,
   ListSchemas200Item,
-  ListSessions200,
-  ListUsers200Item,
+  ListUserPasskeys200,
+  ListUserTeams200,
+  ListUsers200,
   PatchProject200,
   QueryProjects200,
+  QuerySessions200,
+  QueryTeams200,
   SubmitFlowStep200,
   UpdateFlowDefinition200,
+  UpdateTeam200,
   VerifyChallengeProof200,
 } from "../model";
 
-export const getGetOpenIDConfigurationResponseMock = (
-  overrideResponse: Partial<Extract<GetOpenIDConfiguration200, object>> = {},
-): GetOpenIDConfiguration200 => ({
-  issuer: faker.internet.url(),
-  authorization_endpoint: faker.internet.url(),
-  token_endpoint: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  userinfo_endpoint: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  jwks_uri: faker.internet.url(),
-  registration_endpoint: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  scopes_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  response_types_supported: Array.from(
-    { length: faker.number.int({ min: 1, max: 10 }) },
-    (_, i) => i + 1,
-  ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })),
-  response_modes_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  grant_types_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  acr_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  subject_types_supported: faker.helpers.arrayElements(["public", "pairwise"] as const),
-  id_token_signing_alg_values_supported: Array.from(
-    { length: faker.number.int({ min: 1, max: 10 }) },
-    (_, i) => i + 1,
-  ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })),
-  id_token_encryption_alg_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  id_token_encryption_enc_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  userinfo_signing_alg_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  userinfo_encryption_alg_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  userinfo_encryption_enc_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  request_object_signing_alg_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  request_object_encryption_alg_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  request_object_encryption_enc_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  token_endpoint_auth_methods_supported: faker.helpers.arrayElement([
-    faker.helpers.arrayElements([
-      "client_secret_post",
-      "client_secret_basic",
-      "client_secret_jwt",
-      "private_key_jwt",
-    ] as const),
-    undefined,
-  ]),
-  token_endpoint_auth_signing_alg_values_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  display_values_supported: faker.helpers.arrayElement([
-    faker.helpers.arrayElements(["page", "popup", "touch", "wap"] as const),
-    undefined,
-  ]),
-  claim_types_supported: faker.helpers.arrayElement([
-    faker.helpers.arrayElements(["normal", "aggregated", "distributed"] as const),
-    undefined,
-  ]),
-  claims_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  service_documentation: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  claims_locales_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  ui_locales_supported: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-      faker.string.alpha({ length: { min: 10, max: 20 } }),
-    ),
-    undefined,
-  ]),
-  claims_parameter_supported: faker.datatype.boolean(),
-  request_parameter_supported: faker.datatype.boolean(),
-  request_uri_parameter_supported: faker.datatype.boolean(),
-  require_request_uri_registration: faker.datatype.boolean(),
-  op_policy_uri: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  op_tos_uri: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  ...overrideResponse,
-});
-
-export const getAuthorizeDeviceResponseMock = (
-  overrideResponse: Partial<Extract<AuthorizeDevice200, object>> = {},
-): AuthorizeDevice200 => ({
-  device_code: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  expires_in: faker.helpers.arrayElement([faker.number.int(), undefined]),
-  interval: faker.helpers.arrayElement([faker.number.int(), undefined]),
-  user_code: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  verification_uri: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  verification_uri_complete: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
+export const getCreateUserResponseMock = (
+  overrideResponse: Partial<Extract<CreateUser201, object>> = {},
+): CreateUser201 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
   ...overrideResponse,
 });
 
-export const getIntrospectResponseMock = (
-  overrideResponse: Partial<Extract<Introspect200, object>> = {},
-): Introspect200 => ({
-  active: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]),
-  aud: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  client_id: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  exp: faker.helpers.arrayElement([faker.number.int(), undefined]),
-  iat: faker.helpers.arrayElement([faker.number.int(), undefined]),
-  iss: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  jti: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  nbf: faker.helpers.arrayElement([faker.number.int(), undefined]),
-  scope: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  sub: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  token_type: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  username: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
+export const getListUsersResponseMock = (
+  overrideResponse: Partial<Extract<ListUsers200, object>> = {},
+): ListUsers200 => ({
+  users: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    id: faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), undefined]),
+    metadata: faker.helpers.arrayElement([
+      {
+        created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+        updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+        status: faker.helpers.arrayElement([
+          "active",
+          "suspended",
+          "deactivated",
+          "pending_purge",
+        ] as const),
+        lifecycle_owner_team_id: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+          undefined,
+        ]),
+      },
+      undefined,
+    ]),
+  })),
+  next_page_token: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
     undefined,
   ]),
   ...overrideResponse,
 });
 
-export const getGetKeysResponseMock = (
-  overrideResponse: Partial<Extract<GetKeys200, object>> = {},
-): GetKeys200 => ({
-  keys: faker.helpers.arrayElement([
-    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-      use: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      kty: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      kid: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      crv: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      alg: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      k: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      x: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      y: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      n: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      e: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      d: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      p: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      q: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      dp: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      dq: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      qi: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      x5c: faker.helpers.arrayElement([
-        Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-          faker.string.alpha({ length: { min: 10, max: 20 } }),
-        ),
-        undefined,
-      ]),
-      x5u: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      x5t: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
-        undefined,
-      ]),
-      x5tS256: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
+export const getGetUserByIDResponseMock = (
+  overrideResponse: Partial<Extract<GetUserByID200, object>> = {},
+): GetUserByID200 => ({
+  id: faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), undefined]),
+  metadata: faker.helpers.arrayElement([
+    {
+      created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+      updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+      status: faker.helpers.arrayElement([
+        "active",
+        "suspended",
+        "deactivated",
+        "pending_purge",
+      ] as const),
+      lifecycle_owner_team_id: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
         undefined,
       ]),
-    })),
+    },
     undefined,
   ]),
   ...overrideResponse,
 });
 
-export const getGetTokenResponseMock = (
-  overrideResponse: Partial<Extract<GetToken200, object>> = {},
-): GetToken200 => ({
-  access_token: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  token_type: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  expires_in: faker.helpers.arrayElement([faker.number.int(), undefined]),
-  refresh_token: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
+export const getListUserPasskeysResponseMock = (
+  overrideResponse: Partial<Extract<ListUserPasskeys200, object>> = {},
+): ListUserPasskeys200 => ({
+  passkeys: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+    }),
+  ),
+  next_page_token: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
     undefined,
   ]),
   ...overrideResponse,
 });
 
-export const getGetUserInfoResponseMock = (
-  overrideResponse: Partial<Extract<GetUserInfo200, object>> = {},
-): GetUserInfo200 => ({
-  sub: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  name: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  email: faker.helpers.arrayElement([faker.internet.email(), undefined]),
-  preferred_username: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  picture: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-  given_name: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
-    undefined,
-  ]),
-  family_name: faker.helpers.arrayElement([
-    faker.string.alpha({ length: { min: 10, max: 20 } }),
+export const getListUserTeamsResponseMock = (
+  overrideResponse: Partial<Extract<ListUserTeams200, object>> = {},
+): ListUserTeams200 => ({
+  teams: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    membership_status: faker.helpers.arrayElement(["pending", "active", "inactive"] as const),
+    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+    updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  })),
+  next_page_token: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
     undefined,
   ]),
   ...overrideResponse,
 });
 
-export const getCreateUserResponseMock = (
-  overrideResponse: Partial<Extract<CreateUser201, object>> = {},
-): CreateUser201 => ({
-  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+export const getGetMyUserResponseMock = (
+  overrideResponse: Partial<Extract<GetMyUser200, object>> = {},
+): GetMyUser200 => ({
+  id: faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), undefined]),
+  metadata: faker.helpers.arrayElement([
+    {
+      created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+      updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+      status: faker.helpers.arrayElement([
+        "active",
+        "suspended",
+        "deactivated",
+        "pending_purge",
+      ] as const),
+      lifecycle_owner_team_id: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+    },
+    undefined,
+  ]),
   ...overrideResponse,
 });
 
-export const getListUsersResponseMock = (): ListUsers200Item[] =>
-  Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({}));
-
-export const getGetUserByIDResponseMock = (): GetUserByID200 => ({});
-
-export const getGetMyUserResponseMock = (): GetMyUser200 => ({});
-
 export const getCreateFlowResponseMock = (
   overrideResponse: Partial<Extract<CreateFlow201, object>> = {},
 ): CreateFlow201 => ({
@@ -534,7 +295,7 @@ export const getCreateFlowResponseMock = (
     {
       layout: faker.helpers.arrayElement(["centered", "split"] as const),
       liquid_template: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
+        faker.string.alpha({ length: { min: 10, max: 131072 } }),
         undefined,
       ]),
       logo_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
@@ -676,7 +437,7 @@ export const getGetFlowStepResponseMock = (
     {
       layout: faker.helpers.arrayElement(["centered", "split"] as const),
       liquid_template: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
+        faker.string.alpha({ length: { min: 10, max: 131072 } }),
         undefined,
       ]),
       logo_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
@@ -818,7 +579,7 @@ export const getSubmitFlowStepResponseMock = (
     {
       layout: faker.helpers.arrayElement(["centered", "split"] as const),
       liquid_template: faker.helpers.arrayElement([
-        faker.string.alpha({ length: { min: 10, max: 20 } }),
+        faker.string.alpha({ length: { min: 10, max: 131072 } }),
         undefined,
       ]),
       logo_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
@@ -842,11 +603,11 @@ export const getSubmitFlowStepResponseMock = (
 export const getCreateAuthAttemptResponseMock = (
   overrideResponse: Partial<Extract<CreateAuthAttempt201, object>> = {},
 ): CreateAuthAttempt201 => ({
-  attempt_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  attempt_id: faker.helpers.fromRegExp("^att_[a-zA-Z0-9_-]+$"),
   project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
   state: faker.helpers.arrayElement(["in_progress", "completed", "failed", "expired"] as const),
   session_id: faker.helpers.arrayElement([
-    faker.helpers.arrayElement([faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"), null]),
+    faker.helpers.arrayElement([faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"), null]),
     undefined,
   ]),
   user_id: faker.helpers.arrayElement([
@@ -882,7 +643,7 @@ export const getCreateAuthAttemptResponseMock = (
   ]),
   challenges: faker.helpers.arrayElement([
     Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-      challenge_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+      challenge_id: faker.helpers.fromRegExp("^ch_[a-zA-Z0-9_-]+$"),
       method: faker.helpers.arrayElement(["identifier", "password", "passkey"] as const),
       state: faker.helpers.arrayElement(["pending", "failed", "expired"] as const),
       created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
@@ -931,11 +692,11 @@ export const getCreateAuthAttemptResponseMock = (
 export const getGetAuthAttemptResponseMock = (
   overrideResponse: Partial<Extract<GetAuthAttempt200, object>> = {},
 ): GetAuthAttempt200 => ({
-  attempt_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  attempt_id: faker.helpers.fromRegExp("^att_[a-zA-Z0-9_-]+$"),
   project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
   state: faker.helpers.arrayElement(["in_progress", "completed", "failed", "expired"] as const),
   session_id: faker.helpers.arrayElement([
-    faker.helpers.arrayElement([faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"), null]),
+    faker.helpers.arrayElement([faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"), null]),
     undefined,
   ]),
   user_id: faker.helpers.arrayElement([
@@ -971,7 +732,7 @@ export const getGetAuthAttemptResponseMock = (
   ]),
   challenges: faker.helpers.arrayElement([
     Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-      challenge_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+      challenge_id: faker.helpers.fromRegExp("^ch_[a-zA-Z0-9_-]+$"),
       method: faker.helpers.arrayElement(["identifier", "password", "passkey"] as const),
       state: faker.helpers.arrayElement(["pending", "failed", "expired"] as const),
       created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
@@ -1020,7 +781,7 @@ export const getGetAuthAttemptResponseMock = (
 export const getIssueChallengeResponseMock = (
   overrideResponse: Partial<Extract<IssueChallenge201, object>> = {},
 ): IssueChallenge201 => ({
-  challenge_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  challenge_id: faker.helpers.fromRegExp("^ch_[a-zA-Z0-9_-]+$"),
   method: faker.helpers.arrayElement(["identifier", "password", "passkey"] as const),
   state: faker.helpers.arrayElement(["pending", "failed", "expired"] as const),
   created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
@@ -1061,11 +822,11 @@ export const getIssueChallengeResponseMock = (
 export const getVerifyChallengeProofResponseMock = (
   overrideResponse: Partial<Extract<VerifyChallengeProof200, object>> = {},
 ): VerifyChallengeProof200 => ({
-  attempt_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  attempt_id: faker.helpers.fromRegExp("^att_[a-zA-Z0-9_-]+$"),
   project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
   state: faker.helpers.arrayElement(["in_progress", "completed", "failed", "expired"] as const),
   session_id: faker.helpers.arrayElement([
-    faker.helpers.arrayElement([faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"), null]),
+    faker.helpers.arrayElement([faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"), null]),
     undefined,
   ]),
   user_id: faker.helpers.arrayElement([
@@ -1101,7 +862,7 @@ export const getVerifyChallengeProofResponseMock = (
   ]),
   challenges: faker.helpers.arrayElement([
     Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-      challenge_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+      challenge_id: faker.helpers.fromRegExp("^ch_[a-zA-Z0-9_-]+$"),
       method: faker.helpers.arrayElement(["identifier", "password", "passkey"] as const),
       state: faker.helpers.arrayElement(["pending", "failed", "expired"] as const),
       created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
@@ -1160,13 +921,13 @@ export const getCreateProjectResponseMock = (
 ): CreateProject201 => ({
   id: faker.string.alpha({ length: { min: 10, max: 20 } }),
   name: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  projectSecret: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  previewSecret: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  previewOrigins: Array.from(
+  project_secret: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  preview_secret: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  preview_origins: Array.from(
     { length: faker.number.int({ min: 1, max: 10 }) },
     (_, i) => i + 1,
   ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })),
-  createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
   ...overrideResponse,
 });
 
@@ -1177,14 +938,14 @@ export const getQueryProjectsResponseMock = (
     () => ({
       id: faker.string.alpha({ length: { min: 10, max: 20 } }),
       name: faker.string.alpha({ length: { min: 10, max: 20 } }),
-      previewOrigins: faker.helpers.arrayElement([
+      preview_origins: faker.helpers.arrayElement([
         Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
           faker.string.alpha({ length: { min: 10, max: 20 } }),
         ),
         undefined,
       ]),
-      createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
-      updatedAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+      created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+      updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
     }),
   ),
   next_page_token: faker.helpers.arrayElement([
@@ -1199,14 +960,14 @@ export const getGetProjectResponseMock = (
 ): GetProject200 => ({
   id: faker.string.alpha({ length: { min: 10, max: 20 } }),
   name: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  previewOrigins: faker.helpers.arrayElement([
+  preview_origins: faker.helpers.arrayElement([
     Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
       faker.string.alpha({ length: { min: 10, max: 20 } }),
     ),
     undefined,
   ]),
-  createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
-  updatedAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
   ...overrideResponse,
 });
 
@@ -1215,14 +976,43 @@ export const getPatchProjectResponseMock = (
 ): PatchProject200 => ({
   id: faker.string.alpha({ length: { min: 10, max: 20 } }),
   name: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  previewOrigins: faker.helpers.arrayElement([
+  preview_origins: faker.helpers.arrayElement([
     Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
       faker.string.alpha({ length: { min: 10, max: 20 } }),
     ),
     undefined,
   ]),
-  createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
-  updatedAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  ...overrideResponse,
+});
+
+export const getInitClaimResponseMock = (
+  overrideResponse: Partial<Extract<InitClaim201, object>> = {},
+): InitClaim201 => ({
+  claim_url: faker.internet.url(),
+  challenge_id: faker.helpers.fromRegExp("^ch_[a-zA-Z0-9_-]+$"),
+  expires_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  ...overrideResponse,
+});
+
+export const getGetClaimStatusResponseMock = (): GetClaimStatus200 =>
+  faker.helpers.arrayElement([
+    { status: faker.helpers.arrayElement(["pending"] as const) },
+    {
+      status: faker.helpers.arrayElement(["completed"] as const),
+      team_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+      claimed_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+      dashboard_url: faker.internet.url(),
+    },
+  ]);
+
+export const getCompleteClaimResponseMock = (
+  overrideResponse: Partial<Extract<CompleteClaim200, object>> = {},
+): CompleteClaim200 => ({
+  project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  team_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  claimed_at: faker.date.past().toISOString().slice(0, 19) + "Z",
   ...overrideResponse,
 });
 
@@ -1230,9 +1020,9 @@ export const getCreateSessionResponseMock = (
   overrideResponse: Partial<Extract<CreateSession201, object>> = {},
 ): CreateSession201 => ({
   session: {
-    session_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+    session_id: faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"),
     project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
-    state: faker.helpers.arrayElement(["building", "active", "expired", "revoked"] as const),
+    state: faker.helpers.arrayElement(["building", "active", "expired"] as const),
     user_id: faker.helpers.arrayElement([
       faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), null]),
       undefined,
@@ -1297,14 +1087,14 @@ export const getCreateSessionResponseMock = (
   ...overrideResponse,
 });
 
-export const getListSessionsResponseMock = (
-  overrideResponse: Partial<Extract<ListSessions200, object>> = {},
-): ListSessions200 => ({
+export const getQuerySessionsResponseMock = (
+  overrideResponse: Partial<Extract<QuerySessions200, object>> = {},
+): QuerySessions200 => ({
   sessions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
     () => ({
-      session_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+      session_id: faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"),
       project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
-      state: faker.helpers.arrayElement(["building", "active", "expired", "revoked"] as const),
+      state: faker.helpers.arrayElement(["building", "active", "expired"] as const),
       user_id: faker.helpers.arrayElement([
         faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), null]),
         undefined,
@@ -1377,9 +1167,9 @@ export const getExchangeHandoffResponseMock = (
   overrideResponse: Partial<Extract<ExchangeHandoff200, object>> = {},
 ): ExchangeHandoff200 => ({
   session: {
-    session_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+    session_id: faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"),
     project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
-    state: faker.helpers.arrayElement(["building", "active", "expired", "revoked"] as const),
+    state: faker.helpers.arrayElement(["building", "active", "expired"] as const),
     user_id: faker.helpers.arrayElement([
       faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), null]),
       undefined,
@@ -1447,9 +1237,9 @@ export const getExchangeHandoffResponseMock = (
 export const getGetSessionResponseMock = (
   overrideResponse: Partial<Extract<GetSession200, object>> = {},
 ): GetSession200 => ({
-  session_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  session_id: faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"),
   project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
-  state: faker.helpers.arrayElement(["building", "active", "expired", "revoked"] as const),
+  state: faker.helpers.arrayElement(["building", "active", "expired"] as const),
   user_id: faker.helpers.arrayElement([
     faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), null]),
     undefined,
@@ -1515,9 +1305,9 @@ export const getGetSessionResponseMock = (
 export const getGetMySessionResponseMock = (
   overrideResponse: Partial<Extract<GetMySession200, object>> = {},
 ): GetMySession200 => ({
-  session_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
+  session_id: faker.helpers.fromRegExp("^sess_[a-zA-Z0-9_-]+$"),
   project_id: faker.helpers.fromRegExp("^[a-zA-Z0-9_-]+$"),
-  state: faker.helpers.arrayElement(["building", "active", "expired", "revoked"] as const),
+  state: faker.helpers.arrayElement(["building", "active", "expired"] as const),
   user_id: faker.helpers.arrayElement([
     faker.helpers.arrayElement([faker.helpers.fromRegExp("^user_[a-zA-Z0-9_-]+$"), null]),
     undefined,
@@ -1590,7 +1380,7 @@ export const getCreateSchemaResponseMock = (
 export const getListSchemasResponseMock = (): ListSchemas200Item[] =>
   Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
     id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
   }));
 
 export const getGetSchemaByIdResponseMock = (): GetSchemaById200 =>
@@ -1651,7 +1441,12 @@ export const getGetSchemaByIdResponseMock = (): GetSchemaById200 =>
             "x-editable": faker.datatype.boolean(),
             "x-sensitive": faker.datatype.boolean(),
             "x-mfa": faker.datatype.boolean(),
-            properties: faker.helpers.arrayElement([{}, undefined]),
+            properties: faker.helpers.arrayElement([
+              {
+                [faker.string.alphanumeric(5)]: {},
+              },
+              undefined,
+            ]),
           },
         },
         undefined,
@@ -1979,7 +1774,27 @@ export const getCreateTeamResponseMock = (
   overrideResponse: Partial<Extract<CreateTeam201, object>> = {},
 ): CreateTeam201 => ({
   id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+  name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  status: faker.helpers.arrayElement(["active", "deactivated"] as const),
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  ...overrideResponse,
+});
+
+export const getQueryTeamsResponseMock = (
+  overrideResponse: Partial<Extract<QueryTeams200, object>> = {},
+): QueryTeams200 => ({
+  teams: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    status: faker.helpers.arrayElement(["active", "deactivated"] as const),
+    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+    updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  })),
+  next_page_token: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+    undefined,
+  ]),
   ...overrideResponse,
 });
 
@@ -1987,211 +1802,65 @@ export const getGetTeamResponseMock = (
   overrideResponse: Partial<Extract<GetTeam200, object>> = {},
 ): GetTeam200 => ({
   id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-  createdAt: faker.date.past().toISOString().slice(0, 19) + "Z",
-  updatedAt: faker.date.past().toISOString().slice(0, 19) + "Z",
+  name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  status: faker.helpers.arrayElement(["active", "deactivated"] as const),
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
   ...overrideResponse,
 });
 
-export const getGetOpenIDConfigurationMockHandler = (
-  overrideResponse?:
-    | GetOpenIDConfiguration200
-    | ((
-        info: Parameters<Parameters<typeof http.get>[1]>[0],
-      ) => Promise<GetOpenIDConfiguration200> | GetOpenIDConfiguration200),
-  options?: RequestHandlerOptions,
-) => {
-  return http.get(
-    "*/.well-known/openid-configuration",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
-      return HttpResponse.json(
-        overrideResponse !== undefined
-          ? typeof overrideResponse === "function"
-            ? await overrideResponse(info)
-            : overrideResponse
-          : getGetOpenIDConfigurationResponseMock(),
-        { status: 200 },
-      );
-    },
-    options,
-  );
-};
-
-export const getAuthorizeGetMockHandler = (
-  overrideResponse?:
-    | AuthorizeGetDefault
-    | ((
-        info: Parameters<Parameters<typeof http.get>[1]>[0],
-      ) => Promise<AuthorizeGetDefault> | AuthorizeGetDefault),
-  options?: RequestHandlerOptions,
-) => {
-  return http.get(
-    "*/auth/authorize",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
-      if (typeof overrideResponse === "function") {
-        await overrideResponse(info);
-      }
-
-      return new HttpResponse(null, { status: 200 });
-    },
-    options,
-  );
-};
-
-export const getAuthorizeDeviceMockHandler = (
-  overrideResponse?:
-    | AuthorizeDevice200
-    | ((
-        info: Parameters<Parameters<typeof http.get>[1]>[0],
-      ) => Promise<AuthorizeDevice200> | AuthorizeDevice200),
-  options?: RequestHandlerOptions,
-) => {
-  return http.get(
-    "*/auth/device-authorization",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
-      return HttpResponse.json(
-        overrideResponse !== undefined
-          ? typeof overrideResponse === "function"
-            ? await overrideResponse(info)
-            : overrideResponse
-          : getAuthorizeDeviceResponseMock(),
-        { status: 200 },
-      );
-    },
-    options,
-  );
-};
-
-export const getEndSessionMockHandler = (
-  overrideResponse?:
-    | void
-    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<void> | void),
-  options?: RequestHandlerOptions,
-) => {
-  return http.get(
-    "*/auth/end-session",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
-      if (typeof overrideResponse === "function") {
-        await overrideResponse(info);
-      }
-
-      return new HttpResponse(null, { status: 204 });
-    },
-    options,
-  );
-};
-
-export const getIntrospectMockHandler = (
-  overrideResponse?:
-    | Introspect200
-    | ((
-        info: Parameters<Parameters<typeof http.post>[1]>[0],
-      ) => Promise<Introspect200> | Introspect200),
-  options?: RequestHandlerOptions,
-) => {
-  return http.post(
-    "*/auth/introspect",
-    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
-      return HttpResponse.json(
-        overrideResponse !== undefined
-          ? typeof overrideResponse === "function"
-            ? await overrideResponse(info)
-            : overrideResponse
-          : getIntrospectResponseMock(),
-        { status: 200 },
-      );
-    },
-    options,
-  );
-};
-
-export const getGetKeysMockHandler = (
-  overrideResponse?:
-    | GetKeys200
-    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<GetKeys200> | GetKeys200),
-  options?: RequestHandlerOptions,
-) => {
-  return http.get(
-    "*/auth/keys",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
-      return HttpResponse.json(
-        overrideResponse !== undefined
-          ? typeof overrideResponse === "function"
-            ? await overrideResponse(info)
-            : overrideResponse
-          : getGetKeysResponseMock(),
-        { status: 200 },
-      );
-    },
-    options,
-  );
-};
-
-export const getRevokeTokenMockHandler = (
-  overrideResponse?:
-    | void
-    | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<void> | void),
-  options?: RequestHandlerOptions,
-) => {
-  return http.post(
-    "*/auth/revoke",
-    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
-      if (typeof overrideResponse === "function") {
-        await overrideResponse(info);
-      }
+export const getUpdateTeamResponseMock = (
+  overrideResponse: Partial<Extract<UpdateTeam200, object>> = {},
+): UpdateTeam200 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  status: faker.helpers.arrayElement(["active", "deactivated"] as const),
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  ...overrideResponse,
+});
 
-      return new HttpResponse(null, { status: 200 });
-    },
-    options,
-  );
-};
+export const getCreateBrandingResponseMock = (
+  overrideResponse: Partial<Extract<CreateBranding201, object>> = {},
+): CreateBranding201 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  branding: {
+    layout: faker.helpers.arrayElement(["centered", "split"] as const),
+    liquid_template: faker.helpers.arrayElement([
+      faker.string.alpha({ length: { min: 10, max: 131072 } }),
+      undefined,
+    ]),
+    logo_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
+    font_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
+    hero_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
+  },
+  ...overrideResponse,
+});
 
-export const getGetTokenMockHandler = (
-  overrideResponse?:
-    | GetToken200
-    | ((
-        info: Parameters<Parameters<typeof http.post>[1]>[0],
-      ) => Promise<GetToken200> | GetToken200),
-  options?: RequestHandlerOptions,
-) => {
-  return http.post(
-    "*/auth/token",
-    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
-      return HttpResponse.json(
-        overrideResponse !== undefined
-          ? typeof overrideResponse === "function"
-            ? await overrideResponse(info)
-            : overrideResponse
-          : getGetTokenResponseMock(),
-        { status: 200 },
-      );
-    },
-    options,
-  );
-};
+export const getListBrandingResponseMock = (): ListBranding200Item[] =>
+  Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  }));
 
-export const getGetUserInfoMockHandler = (
-  overrideResponse?:
-    | GetUserInfo200
-    | ((
-        info: Parameters<Parameters<typeof http.get>[1]>[0],
-      ) => Promise<GetUserInfo200> | GetUserInfo200),
-  options?: RequestHandlerOptions,
-) => {
-  return http.get(
-    "*/auth/userinfo",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
-      return HttpResponse.json(
-        overrideResponse !== undefined
-          ? typeof overrideResponse === "function"
-            ? await overrideResponse(info)
-            : overrideResponse
-          : getGetUserInfoResponseMock(),
-        { status: 200 },
-      );
-    },
-    options,
-  );
-};
+export const getGetBrandingByIdResponseMock = (
+  overrideResponse: Partial<Extract<GetBrandingById200, object>> = {},
+): GetBrandingById200 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
+  branding: {
+    layout: faker.helpers.arrayElement(["centered", "split"] as const),
+    liquid_template: faker.helpers.arrayElement([
+      faker.string.alpha({ length: { min: 10, max: 131072 } }),
+      undefined,
+    ]),
+    logo_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
+    font_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
+    hero_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
+  },
+  ...overrideResponse,
+});
 
 export const getGetHealthMockHandler = (
   overrideResponse?:
@@ -2282,10 +1951,10 @@ export const getCreateUserMockHandler = (
 
 export const getListUsersMockHandler = (
   overrideResponse?:
-    | ListUsers200Item[]
+    | ListUsers200
     | ((
         info: Parameters<Parameters<typeof http.get>[1]>[0],
-      ) => Promise<ListUsers200Item[]> | ListUsers200Item[]),
+      ) => Promise<ListUsers200> | ListUsers200),
   options?: RequestHandlerOptions,
 ) => {
   return http.get(
@@ -2328,6 +1997,49 @@ export const getGetUserByIDMockHandler = (
   );
 };
 
+export const getDeleteUserByIDMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.delete(
+    "*/users/:userId",
+    async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
+      if (typeof overrideResponse === "function") {
+        await overrideResponse(info);
+      }
+
+      return new HttpResponse(null, { status: 204 });
+    },
+    options,
+  );
+};
+
+export const getListUserPasskeysMockHandler = (
+  overrideResponse?:
+    | ListUserPasskeys200
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<ListUserPasskeys200> | ListUserPasskeys200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    "*/users/:userId/passkeys",
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getListUserPasskeysResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
 export const getSetUserPasswordMockHandler = (
   overrideResponse?:
     | void
@@ -2347,6 +2059,30 @@ export const getSetUserPasswordMockHandler = (
   );
 };
 
+export const getListUserTeamsMockHandler = (
+  overrideResponse?:
+    | ListUserTeams200
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<ListUserTeams200> | ListUserTeams200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    "*/users/:userId/teams",
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getListUserTeamsResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
 export const getGetMyUserMockHandler = (
   overrideResponse?:
     | GetMyUser200
@@ -2443,25 +2179,6 @@ export const getSubmitFlowStepMockHandler = (
   );
 };
 
-export const getSubmitFlowEventMockHandler = (
-  overrideResponse?:
-    | void
-    | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<void> | void),
-  options?: RequestHandlerOptions,
-) => {
-  return http.post(
-    "*/flow/:id/event",
-    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
-      if (typeof overrideResponse === "function") {
-        await overrideResponse(info);
-      }
-
-      return new HttpResponse(null, { status: 204 });
-    },
-    options,
-  );
-};
-
 export const getCreateAuthAttemptMockHandler = (
   overrideResponse?:
     | CreateAuthAttempt201
@@ -2678,6 +2395,78 @@ export const getPatchProjectMockHandler = (
   );
 };
 
+export const getInitClaimMockHandler = (
+  overrideResponse?:
+    | InitClaim201
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<InitClaim201> | InitClaim201),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    "*/projects/:projectId/claim/init",
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getInitClaimResponseMock(),
+        { status: 201 },
+      );
+    },
+    options,
+  );
+};
+
+export const getGetClaimStatusMockHandler = (
+  overrideResponse?:
+    | GetClaimStatus200
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<GetClaimStatus200> | GetClaimStatus200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    "*/projects/:projectId/claim/status",
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetClaimStatusResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
+export const getCompleteClaimMockHandler = (
+  overrideResponse?:
+    | CompleteClaim200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<CompleteClaim200> | CompleteClaim200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    "*/projects/:projectId/claim/complete",
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getCompleteClaimResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
 export const getCreateSessionMockHandler = (
   overrideResponse?:
     | CreateSession201
@@ -2702,23 +2491,23 @@ export const getCreateSessionMockHandler = (
   );
 };
 
-export const getListSessionsMockHandler = (
+export const getQuerySessionsMockHandler = (
   overrideResponse?:
-    | ListSessions200
+    | QuerySessions200
     | ((
-        info: Parameters<Parameters<typeof http.get>[1]>[0],
-      ) => Promise<ListSessions200> | ListSessions200),
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<QuerySessions200> | QuerySessions200),
   options?: RequestHandlerOptions,
 ) => {
-  return http.get(
-    "*/sessions",
-    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+  return http.post(
+    "*/sessions/query",
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
       return HttpResponse.json(
         overrideResponse !== undefined
           ? typeof overrideResponse === "function"
             ? await overrideResponse(info)
             : overrideResponse
-          : getListSessionsResponseMock(),
+          : getQuerySessionsResponseMock(),
         { status: 200 },
       );
     },
@@ -3023,34 +2812,85 @@ export const getDeleteFlowDefinitionMockHandler = (
   );
 };
 
-export const getActivateFlowDefinitionMockHandler = (
+export const getCreateTeamMockHandler = (
   overrideResponse?:
-    | void
-    | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<void> | void),
+    | CreateTeam201
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<CreateTeam201> | CreateTeam201),
   options?: RequestHandlerOptions,
 ) => {
   return http.post(
-    "*/flow_definitions/:id/activate",
+    "*/teams",
     async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
-      if (typeof overrideResponse === "function") {
-        await overrideResponse(info);
-      }
-
-      return new HttpResponse(null, { status: 204 });
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getCreateTeamResponseMock(),
+        { status: 201 },
+      );
     },
     options,
   );
 };
 
-export const getDeactivateFlowDefinitionMockHandler = (
+export const getQueryTeamsMockHandler = (
   overrideResponse?:
-    | void
-    | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<void> | void),
+    | QueryTeams200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<QueryTeams200> | QueryTeams200),
   options?: RequestHandlerOptions,
 ) => {
   return http.post(
-    "*/flow_definitions/:id/deactivate",
+    "*/teams/query",
     async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getQueryTeamsResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
+export const getGetTeamMockHandler = (
+  overrideResponse?:
+    | GetTeam200
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<GetTeam200> | GetTeam200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    "*/teams/:teamId",
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetTeamResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
+export const getDeleteTeamMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.delete(
+    "*/teams/:teamId",
+    async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
       if (typeof overrideResponse === "function") {
         await overrideResponse(info);
       }
@@ -3061,23 +2901,47 @@ export const getDeactivateFlowDefinitionMockHandler = (
   );
 };
 
-export const getCreateTeamMockHandler = (
+export const getUpdateTeamMockHandler = (
   overrideResponse?:
-    | CreateTeam201
+    | UpdateTeam200
+    | ((
+        info: Parameters<Parameters<typeof http.patch>[1]>[0],
+      ) => Promise<UpdateTeam200> | UpdateTeam200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.patch(
+    "*/teams/:teamId",
+    async (info: Parameters<Parameters<typeof http.patch>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getUpdateTeamResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
+export const getCreateBrandingMockHandler = (
+  overrideResponse?:
+    | CreateBranding201
     | ((
         info: Parameters<Parameters<typeof http.post>[1]>[0],
-      ) => Promise<CreateTeam201> | CreateTeam201),
+      ) => Promise<CreateBranding201> | CreateBranding201),
   options?: RequestHandlerOptions,
 ) => {
   return http.post(
-    "*/teams",
+    "*/branding",
     async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
       return HttpResponse.json(
         overrideResponse !== undefined
           ? typeof overrideResponse === "function"
             ? await overrideResponse(info)
             : overrideResponse
-          : getCreateTeamResponseMock(),
+          : getCreateBrandingResponseMock(),
         { status: 201 },
       );
     },
@@ -3085,21 +2949,47 @@ export const getCreateTeamMockHandler = (
   );
 };
 
-export const getGetTeamMockHandler = (
+export const getListBrandingMockHandler = (
   overrideResponse?:
-    | GetTeam200
-    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<GetTeam200> | GetTeam200),
+    | ListBranding200Item[]
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<ListBranding200Item[]> | ListBranding200Item[]),
   options?: RequestHandlerOptions,
 ) => {
   return http.get(
-    "*/teams/:teamId",
+    "*/branding",
     async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
       return HttpResponse.json(
         overrideResponse !== undefined
           ? typeof overrideResponse === "function"
             ? await overrideResponse(info)
             : overrideResponse
-          : getGetTeamResponseMock(),
+          : getListBrandingResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
+export const getGetBrandingByIdMockHandler = (
+  overrideResponse?:
+    | GetBrandingById200
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<GetBrandingById200> | GetBrandingById200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    "*/branding/:id",
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetBrandingByIdResponseMock(),
         { status: 200 },
       );
     },
@@ -3107,27 +2997,20 @@ export const getGetTeamMockHandler = (
   );
 };
 export const getZitadelNextGenMock = () => [
-  getGetOpenIDConfigurationMockHandler(),
-  getAuthorizeGetMockHandler(),
-  getAuthorizeDeviceMockHandler(),
-  getEndSessionMockHandler(),
-  getIntrospectMockHandler(),
-  getGetKeysMockHandler(),
-  getRevokeTokenMockHandler(),
-  getGetTokenMockHandler(),
-  getGetUserInfoMockHandler(),
   getGetHealthMockHandler(),
   getGetLiveMockHandler(),
   getGetReadyMockHandler(),
   getCreateUserMockHandler(),
   getListUsersMockHandler(),
   getGetUserByIDMockHandler(),
+  getDeleteUserByIDMockHandler(),
+  getListUserPasskeysMockHandler(),
   getSetUserPasswordMockHandler(),
+  getListUserTeamsMockHandler(),
   getGetMyUserMockHandler(),
   getCreateFlowMockHandler(),
   getGetFlowStepMockHandler(),
   getSubmitFlowStepMockHandler(),
-  getSubmitFlowEventMockHandler(),
   getCreateAuthAttemptMockHandler(),
   getGetAuthAttemptMockHandler(),
   getIssueChallengeMockHandler(),
@@ -3137,8 +3020,11 @@ export const getZitadelNextGenMock = () => [
   getQueryProjectsMockHandler(),
   getGetProjectMockHandler(),
   getPatchProjectMockHandler(),
+  getInitClaimMockHandler(),
+  getGetClaimStatusMockHandler(),
+  getCompleteClaimMockHandler(),
   getCreateSessionMockHandler(),
-  getListSessionsMockHandler(),
+  getQuerySessionsMockHandler(),
   getExchangeHandoffMockHandler(),
   getGetSessionMockHandler(),
   getRevokeSessionMockHandler(),
@@ -3152,8 +3038,12 @@ export const getZitadelNextGenMock = () => [
   getGetFlowDefinitionMockHandler(),
   getUpdateFlowDefinitionMockHandler(),
   getDeleteFlowDefinitionMockHandler(),
-  getActivateFlowDefinitionMockHandler(),
-  getDeactivateFlowDefinitionMockHandler(),
   getCreateTeamMockHandler(),
+  getQueryTeamsMockHandler(),
   getGetTeamMockHandler(),
+  getDeleteTeamMockHandler(),
+  getUpdateTeamMockHandler(),
+  getCreateBrandingMockHandler(),
+  getListBrandingMockHandler(),
+  getGetBrandingByIdMockHandler(),
 ];