@zitadel/api 0.0.0 → 0.1.0-alpha.10

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

@@ -29,6 +29,7 @@ import type {
   GetKeys200,
   GetLiveDefault,
   GetMySession200,
+  GetMyUser200,
   GetOpenIDConfiguration200,
   GetProject200,
   GetReadyDefault,
@@ -407,6 +408,8 @@ export const getListUsersResponseMock = (): ListUsers200Item[] =>
 
 export const getGetUserByIDResponseMock = (): GetUserByID200 => ({});
 
+export const getGetMyUserResponseMock = (): GetMyUser200 => ({});
+
 export const getCreateFlowResponseMock = (
   overrideResponse: Partial<Extract<CreateFlow201, object>> = {},
 ): CreateFlow201 => ({
@@ -440,8 +443,9 @@ export const getCreateFlowResponseMock = (
       undefined,
     ]),
     redirect_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-    fields: {
-      [faker.string.alphanumeric(5)]: {
+    fields: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
         type: faker.helpers.arrayElement([
           "text",
           "email",
@@ -451,6 +455,8 @@ export const getCreateFlowResponseMock = (
           "url",
           "date",
           "hidden",
+          "checkbox",
+          "select",
         ] as const),
         text_key: faker.string.alpha({ length: { min: 10, max: 20 } }),
         required: faker.datatype.boolean(),
@@ -463,20 +469,27 @@ export const getCreateFlowResponseMock = (
             ]),
             min_length: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
             max_length: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+            enum: 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,
+            ]),
           },
           undefined,
         ]),
-      },
-    },
-    actions: {
-      [faker.string.alphanumeric(5)]: {
+      }),
+    ),
+    actions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
         primary: faker.datatype.boolean(),
         text_key: faker.helpers.arrayElement([
           faker.string.alpha({ length: { min: 10, max: 20 } }),
           undefined,
         ]),
-      },
-    },
+      }),
+    ),
     gates: {
       [faker.string.alphanumeric(5)]: {
         kind: faker.helpers.arrayElement(["captcha"] as const),
@@ -565,8 +578,9 @@ export const getGetFlowStepResponseMock = (
       undefined,
     ]),
     redirect_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-    fields: {
-      [faker.string.alphanumeric(5)]: {
+    fields: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
         type: faker.helpers.arrayElement([
           "text",
           "email",
@@ -576,6 +590,8 @@ export const getGetFlowStepResponseMock = (
           "url",
           "date",
           "hidden",
+          "checkbox",
+          "select",
         ] as const),
         text_key: faker.string.alpha({ length: { min: 10, max: 20 } }),
         required: faker.datatype.boolean(),
@@ -588,20 +604,27 @@ export const getGetFlowStepResponseMock = (
             ]),
             min_length: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
             max_length: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+            enum: 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,
+            ]),
           },
           undefined,
         ]),
-      },
-    },
-    actions: {
-      [faker.string.alphanumeric(5)]: {
+      }),
+    ),
+    actions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
         primary: faker.datatype.boolean(),
         text_key: faker.helpers.arrayElement([
           faker.string.alpha({ length: { min: 10, max: 20 } }),
           undefined,
         ]),
-      },
-    },
+      }),
+    ),
     gates: {
       [faker.string.alphanumeric(5)]: {
         kind: faker.helpers.arrayElement(["captcha"] as const),
@@ -690,8 +713,9 @@ export const getSubmitFlowStepResponseMock = (
       undefined,
     ]),
     redirect_url: faker.helpers.arrayElement([faker.internet.url(), undefined]),
-    fields: {
-      [faker.string.alphanumeric(5)]: {
+    fields: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
         type: faker.helpers.arrayElement([
           "text",
           "email",
@@ -701,6 +725,8 @@ export const getSubmitFlowStepResponseMock = (
           "url",
           "date",
           "hidden",
+          "checkbox",
+          "select",
         ] as const),
         text_key: faker.string.alpha({ length: { min: 10, max: 20 } }),
         required: faker.datatype.boolean(),
@@ -713,20 +739,27 @@ export const getSubmitFlowStepResponseMock = (
             ]),
             min_length: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
             max_length: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+            enum: 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,
+            ]),
           },
           undefined,
         ]),
-      },
-    },
-    actions: {
-      [faker.string.alphanumeric(5)]: {
+      }),
+    ),
+    actions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
         primary: faker.datatype.boolean(),
         text_key: faker.helpers.arrayElement([
           faker.string.alpha({ length: { min: 10, max: 20 } }),
           undefined,
         ]),
-      },
-    },
+      }),
+    ),
     gates: {
       [faker.string.alphanumeric(5)]: {
         kind: faker.helpers.arrayElement(["captcha"] as const),
@@ -1504,8 +1537,13 @@ export const getGetSchemaByIdResponseMock = (): GetSchemaById200 =>
     },
   ]);
 
-export const getCreateFlowDefinitionResponseMock = (): CreateFlowDefinition201 => ({
-  ...{
+export const getCreateFlowDefinitionResponseMock = (
+  overrideResponse: Partial<Extract<CreateFlowDefinition201, object>> = {},
+): CreateFlowDefinition201 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  status: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  flow_definition: {
     name: faker.helpers.fromRegExp("^[a-z][a-z0-9-]*$"),
     user_schema: faker.internet.url(),
     purposes: {
@@ -1534,15 +1572,16 @@ export const getCreateFlowDefinitionResponseMock = (): CreateFlowDefinition201 =
         fields: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
           () => faker.string.alpha({ length: { min: 10, max: 20 } }),
         ),
-        actions: {
-          [faker.string.alphanumeric(5)]: {
+        actions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+          () => ({
+            name: faker.string.alpha({ length: { min: 10, max: 20 } }),
             primary: faker.datatype.boolean(),
             text_key: faker.helpers.arrayElement([
               faker.string.alpha({ length: { min: 10, max: 20 } }),
               undefined,
             ]),
-          },
-        },
+          }),
+        ),
         gates: {
           [faker.string.alphanumeric(5)]: {
             kind: faker.helpers.arrayElement(["captcha"] as const),
@@ -1584,14 +1623,9 @@ export const getCreateFlowDefinitionResponseMock = (): CreateFlowDefinition201 =
       }),
     ),
   },
-  ...{
-    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    schema_uri: faker.internet.url(),
-    status: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
-    updated_at: 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 getListFlowDefinitionsResponseMock = (
@@ -1604,7 +1638,7 @@ export const getListFlowDefinitionsResponseMock = (
     id: faker.string.alpha({ length: { min: 10, max: 20 } }),
     name: faker.helpers.fromRegExp("^[a-z][a-z0-9-]*$"),
     project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    schema_uri: faker.internet.url(),
+    schema_uri: faker.helpers.arrayElement([faker.internet.url(), undefined]),
     status: faker.string.alpha({ length: { min: 10, max: 20 } }),
     created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
     updated_at: faker.date.past().toISOString().slice(0, 19) + "Z",
@@ -1616,8 +1650,13 @@ export const getListFlowDefinitionsResponseMock = (
   ...overrideResponse,
 });
 
-export const getGetFlowDefinitionResponseMock = (): GetFlowDefinition200 => ({
-  ...{
+export const getGetFlowDefinitionResponseMock = (
+  overrideResponse: Partial<Extract<GetFlowDefinition200, object>> = {},
+): GetFlowDefinition200 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  status: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  flow_definition: {
     name: faker.helpers.fromRegExp("^[a-z][a-z0-9-]*$"),
     user_schema: faker.internet.url(),
     purposes: {
@@ -1646,15 +1685,16 @@ export const getGetFlowDefinitionResponseMock = (): GetFlowDefinition200 => ({
         fields: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
           () => faker.string.alpha({ length: { min: 10, max: 20 } }),
         ),
-        actions: {
-          [faker.string.alphanumeric(5)]: {
+        actions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+          () => ({
+            name: faker.string.alpha({ length: { min: 10, max: 20 } }),
             primary: faker.datatype.boolean(),
             text_key: faker.helpers.arrayElement([
               faker.string.alpha({ length: { min: 10, max: 20 } }),
               undefined,
             ]),
-          },
-        },
+          }),
+        ),
         gates: {
           [faker.string.alphanumeric(5)]: {
             kind: faker.helpers.arrayElement(["captcha"] as const),
@@ -1696,18 +1736,18 @@ export const getGetFlowDefinitionResponseMock = (): GetFlowDefinition200 => ({
       }),
     ),
   },
-  ...{
-    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    schema_uri: faker.internet.url(),
-    status: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
-    updated_at: 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 getUpdateFlowDefinitionResponseMock = (): UpdateFlowDefinition200 => ({
-  ...{
+export const getUpdateFlowDefinitionResponseMock = (
+  overrideResponse: Partial<Extract<UpdateFlowDefinition200, object>> = {},
+): UpdateFlowDefinition200 => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  status: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  flow_definition: {
     name: faker.helpers.fromRegExp("^[a-z][a-z0-9-]*$"),
     user_schema: faker.internet.url(),
     purposes: {
@@ -1736,15 +1776,16 @@ export const getUpdateFlowDefinitionResponseMock = (): UpdateFlowDefinition200 =
         fields: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
           () => faker.string.alpha({ length: { min: 10, max: 20 } }),
         ),
-        actions: {
-          [faker.string.alphanumeric(5)]: {
+        actions: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+          () => ({
+            name: faker.string.alpha({ length: { min: 10, max: 20 } }),
             primary: faker.datatype.boolean(),
             text_key: faker.helpers.arrayElement([
               faker.string.alpha({ length: { min: 10, max: 20 } }),
               undefined,
             ]),
-          },
-        },
+          }),
+        ),
         gates: {
           [faker.string.alphanumeric(5)]: {
             kind: faker.helpers.arrayElement(["captcha"] as const),
@@ -1786,14 +1827,9 @@ export const getUpdateFlowDefinitionResponseMock = (): UpdateFlowDefinition200 =
       }),
     ),
   },
-  ...{
-    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    project_id: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    schema_uri: faker.internet.url(),
-    status: faker.string.alpha({ length: { min: 10, max: 20 } }),
-    created_at: faker.date.past().toISOString().slice(0, 19) + "Z",
-    updated_at: 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 getCreateTeamResponseMock = (
@@ -2086,7 +2122,7 @@ export const getCreateUserMockHandler = (
   options?: RequestHandlerOptions,
 ) => {
   return http.post(
-    "*/user",
+    "*/users",
     async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
       return HttpResponse.json(
         overrideResponse !== undefined
@@ -2110,7 +2146,7 @@ export const getListUsersMockHandler = (
   options?: RequestHandlerOptions,
 ) => {
   return http.get(
-    "*/user",
+    "*/users",
     async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
       return HttpResponse.json(
         overrideResponse !== undefined
@@ -2134,7 +2170,7 @@ export const getGetUserByIDMockHandler = (
   options?: RequestHandlerOptions,
 ) => {
   return http.get(
-    "*/user/:userId",
+    "*/users/:userId",
     async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
       return HttpResponse.json(
         overrideResponse !== undefined
@@ -2149,6 +2185,49 @@ export const getGetUserByIDMockHandler = (
   );
 };
 
+export const getSetUserPasswordMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.put>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.put(
+    "*/users/:userId/password",
+    async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
+      if (typeof overrideResponse === "function") {
+        await overrideResponse(info);
+      }
+
+      return new HttpResponse(null, { status: 204 });
+    },
+    options,
+  );
+};
+
+export const getGetMyUserMockHandler = (
+  overrideResponse?:
+    | GetMyUser200
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<GetMyUser200> | GetMyUser200),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    "*/users/me",
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetMyUserResponseMock(),
+        { status: 200 },
+      );
+    },
+    options,
+  );
+};
+
 export const getCreateFlowMockHandler = (
   overrideResponse?:
     | CreateFlow201
@@ -2790,6 +2869,8 @@ export const getZitadelNextGenMock = () => [
   getCreateUserMockHandler(),
   getListUsersMockHandler(),
   getGetUserByIDMockHandler(),
+  getSetUserPasswordMockHandler(),
+  getGetMyUserMockHandler(),
   getCreateFlowMockHandler(),
   getGetFlowStepMockHandler(),
   getSubmitFlowStepMockHandler(),

package/src/generated/endpoints/zitadelNextGen.ts

@@ -32,17 +32,20 @@ import type {
   CreateUser201,
   CreateUserBody,
   CreateUserParams,
+  DeleteFlowDefinitionParams,
   EndSessionParams,
   ExchangeHandoff200,
   ExchangeHandoffBody,
   ExchangeHandoffParams,
   GetAuthAttempt200,
   GetFlowDefinition200,
+  GetFlowDefinitionParams,
   GetFlowStep200,
   GetHealthDefault,
   GetKeys200,
   GetLiveDefault,
   GetMySession200,
+  GetMyUser200,
   GetOpenIDConfiguration200,
   GetProject200,
   GetReadyDefault,
@@ -69,11 +72,14 @@ import type {
   ListUsersParams,
   RevokeSessionParams,
   RevokeTokenBody,
+  SetUserPasswordBody,
+  SetUserPasswordParams,
   SubmitFlowEventBody,
   SubmitFlowStep200,
   SubmitFlowStepBody,
   UpdateFlowDefinition200,
   UpdateFlowDefinitionBody,
+  UpdateFlowDefinitionParams,
   VerifyChallengeProof200,
   VerifyChallengeProofBody,
 } from "../model";
@@ -364,8 +370,8 @@ export const getCreateUserUrl = (params: CreateUserParams) => {
   const stringifiedParams = normalizedParams.toString();
 
   return stringifiedParams.length > 0
-    ? `${getProxyPath()}/user?${stringifiedParams}`
-    : `${getProxyPath()}/user`;
+    ? `${getProxyPath()}/users?${stringifiedParams}`
+    : `${getProxyPath()}/users`;
 };
 
 /**
@@ -396,8 +402,8 @@ export const getListUsersUrl = (params?: ListUsersParams) => {
   const stringifiedParams = normalizedParams.toString();
 
   return stringifiedParams.length > 0
-    ? `${getProxyPath()}/user?${stringifiedParams}`
-    : `${getProxyPath()}/user`;
+    ? `${getProxyPath()}/users?${stringifiedParams}`
+    : `${getProxyPath()}/users`;
 };
 
 /**
@@ -425,8 +431,8 @@ export const getGetUserByIDUrl = (userId: string, params: GetUserByIDParams) =>
   const stringifiedParams = normalizedParams.toString();
 
   return stringifiedParams.length > 0
-    ? `${getProxyPath()}/user/${userId}?${stringifiedParams}`
-    : `${getProxyPath()}/user/${userId}`;
+    ? `${getProxyPath()}/users/${userId}?${stringifiedParams}`
+    : `${getProxyPath()}/users/${userId}`;
 };
 
 /**
@@ -443,6 +449,53 @@ export const getUserByID = async (
   });
 };
 
+export const getSetUserPasswordUrl = (userId: string, params: SetUserPasswordParams) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0
+    ? `${getProxyPath()}/users/${userId}/password?${stringifiedParams}`
+    : `${getProxyPath()}/users/${userId}/password`;
+};
+
+/**
+ * @summary Set user password
+ */
+export const setUserPassword = async (
+  userId: string,
+  setUserPasswordBody: SetUserPasswordBody,
+  params: SetUserPasswordParams,
+  options?: RequestInit,
+): Promise<void> => {
+  return customFetch<void>(getSetUserPasswordUrl(userId, params), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(setUserPasswordBody),
+  });
+};
+
+export const getGetMyUserUrl = () => {
+  return `${getProxyPath()}/users/me`;
+};
+
+/**
+ * @summary Get my user information
+ */
+export const getMyUser = async (options?: RequestInit): Promise<GetMyUser200> => {
+  return customFetch<GetMyUser200>(getGetMyUserUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
 export const getCreateFlowUrl = () => {
   return `${getProxyPath()}/flow`;
 };
@@ -1094,8 +1147,20 @@ export const listFlowDefinitions = async (
   });
 };
 
-export const getGetFlowDefinitionUrl = (id: string) => {
-  return `${getProxyPath()}/flow_definitions/${id}`;
+export const getGetFlowDefinitionUrl = (id: string, params: GetFlowDefinitionParams) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0
+    ? `${getProxyPath()}/flow_definitions/${id}?${stringifiedParams}`
+    : `${getProxyPath()}/flow_definitions/${id}`;
 };
 
 /**
@@ -1104,16 +1169,29 @@ export const getGetFlowDefinitionUrl = (id: string) => {
  */
 export const getFlowDefinition = async (
   id: string,
+  params: GetFlowDefinitionParams,
   options?: RequestInit,
 ): Promise<GetFlowDefinition200> => {
-  return customFetch<GetFlowDefinition200>(getGetFlowDefinitionUrl(id), {
+  return customFetch<GetFlowDefinition200>(getGetFlowDefinitionUrl(id, params), {
     ...options,
     method: "GET",
   });
 };
 
-export const getUpdateFlowDefinitionUrl = (id: string) => {
-  return `${getProxyPath()}/flow_definitions/${id}`;
+export const getUpdateFlowDefinitionUrl = (id: string, params: UpdateFlowDefinitionParams) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0
+    ? `${getProxyPath()}/flow_definitions/${id}?${stringifiedParams}`
+    : `${getProxyPath()}/flow_definitions/${id}`;
 };
 
 /**
@@ -1123,9 +1201,10 @@ export const getUpdateFlowDefinitionUrl = (id: string) => {
 export const updateFlowDefinition = async (
   id: string,
   updateFlowDefinitionBody: UpdateFlowDefinitionBody,
+  params: UpdateFlowDefinitionParams,
   options?: RequestInit,
 ): Promise<UpdateFlowDefinition200> => {
-  return customFetch<UpdateFlowDefinition200>(getUpdateFlowDefinitionUrl(id), {
+  return customFetch<UpdateFlowDefinition200>(getUpdateFlowDefinitionUrl(id, params), {
     ...options,
     method: "PATCH",
     headers: { "Content-Type": "application/json", ...options?.headers },
@@ -1133,16 +1212,32 @@ export const updateFlowDefinition = async (
   });
 };
 
-export const getDeleteFlowDefinitionUrl = (id: string) => {
-  return `${getProxyPath()}/flow_definitions/${id}`;
+export const getDeleteFlowDefinitionUrl = (id: string, params: DeleteFlowDefinitionParams) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0
+    ? `${getProxyPath()}/flow_definitions/${id}?${stringifiedParams}`
+    : `${getProxyPath()}/flow_definitions/${id}`;
 };
 
 /**
  * Delete a flow definition by id
  * @summary Delete a flow definition by id
  */
-export const deleteFlowDefinition = async (id: string, options?: RequestInit): Promise<void> => {
-  return customFetch<void>(getDeleteFlowDefinitionUrl(id), {
+export const deleteFlowDefinition = async (
+  id: string,
+  params: DeleteFlowDefinitionParams,
+  options?: RequestInit,
+): Promise<void> => {
+  return customFetch<void>(getDeleteFlowDefinitionUrl(id, params), {
     ...options,
     method: "DELETE",
   });