@squonk/account-server-client 4.8.1 → 4.9.0-beta.2

package/src/api/capabilities/capabilities.fetch.ts

@@ -0,0 +1,750 @@
+/**
+ * Generated by orval v8.22.0 🍺
+ * Do not edit manually.
+ * Account Server API
+ * The Informatics Matters Account Server API.
+ *
+ * A service that provides access to the Account Server, which gives *registered* users access to and management of **Organisations**, **Units**, **Products**, **Users**, and **Assets**.
+ *
+ * OpenAPI spec version: 4.9
+ */
+import { useMutation, useQuery, useSuspenseQuery } from "@tanstack/react-query";
+import type {
+  DataTag,
+  DefinedInitialDataOptions,
+  DefinedUseQueryResult,
+  InvalidateOptions,
+  MutationFunction,
+  QueryClient,
+  QueryFunction,
+  QueryKey,
+  UndefinedInitialDataOptions,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+  UseSuspenseQueryOptions,
+  UseSuspenseQueryResult,
+} from "@tanstack/react-query";
+
+import type {
+  AsError,
+  CapabilitiesGetResponse,
+  CapabilityPostBodyBody,
+  CapabilityPostResponse,
+} from "../api-schemas";
+
+import { customFetch } from "../../custom-fetch";
+import type { ErrorType } from "../../custom-fetch";
+
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+const withQueryKey = <T extends object, K>(query: T, queryKey: K): T & { queryKey: K } => {
+  const result = { queryKey } as T & { queryKey: K };
+  for (const key of Object.keys(query)) {
+    // The explicit queryKey always wins, matching the previous
+    // `{ ...query, queryKey }` spread where it was set last.
+    if (key === "queryKey") continue;
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      configurable: true,
+      get: () => (query as Record<string, unknown>)[key],
+    });
+  }
+  return result;
+};
+
+export type loadCapabilitiesResponse201 = { data: CapabilityPostResponse; status: 201 };
+
+export type loadCapabilitiesResponse400 = { data: AsError; status: 400 };
+
+export type loadCapabilitiesResponse401 = { data: void; status: 401 };
+
+export type loadCapabilitiesResponse403 = { data: AsError; status: 403 };
+
+export type loadCapabilitiesResponse404 = { data: AsError; status: 404 };
+
+export type loadCapabilitiesResponse409 = { data: AsError; status: 409 };
+
+export type loadCapabilitiesResponse422 = { data: AsError; status: 422 };
+
+export type loadCapabilitiesResponseSuccess = loadCapabilitiesResponse201 & { headers: Headers };
+export type loadCapabilitiesResponseError = (
+  | loadCapabilitiesResponse400
+  | loadCapabilitiesResponse401
+  | loadCapabilitiesResponse403
+  | loadCapabilitiesResponse404
+  | loadCapabilitiesResponse409
+  | loadCapabilitiesResponse422
+) & { headers: Headers };
+
+export type loadCapabilitiesResponse =
+  | loadCapabilitiesResponseSuccess
+  | loadCapabilitiesResponseError;
+
+export const getLoadCapabilitiesUrl = (orgId: string) => {
+  return `/capability/${orgId}`;
+};
+
+/**
+ * Loads the Capabilities defined in a YAML file against an Organisation. Several Capabilities can be loaded at once by concatenating their definitions (as separate YAML documents). Either all the Capabilities in the file are loaded or none of them are.
+ *
+ * A Capability can only be loaded once against an Organisation, and is enabled when it's loaded. The Capabilities that can be loaded, and what goes in their **spec**, are described in the Capability catalogue.
+ *
+ * You need admin rights to use this path.
+ * @summary Loads Capabilities against an Organisation
+ */
+export const loadCapabilities = async (
+  orgId: string,
+  capabilityPostBodyBody: CapabilityPostBodyBody,
+  options?: RequestInit,
+): Promise<loadCapabilitiesResponse> => {
+  const formData = new FormData();
+  formData.append(`capability_file`, capabilityPostBodyBody.capability_file);
+
+  return customFetch<loadCapabilitiesResponse>(getLoadCapabilitiesUrl(orgId), {
+    ...options,
+    method: "POST",
+    body: formData,
+  });
+};
+
+export const getLoadCapabilitiesMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof loadCapabilities>>,
+    TError,
+    { orgId: string; data: CapabilityPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof loadCapabilities>>,
+  TError,
+  { orgId: string; data: CapabilityPostBodyBody },
+  TContext
+> => {
+  const mutationKey = ["loadCapabilities"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof loadCapabilities>>,
+    { orgId: string; data: CapabilityPostBodyBody }
+  > = (props) => {
+    const { orgId, data } = props ?? {};
+
+    return loadCapabilities(orgId, data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type LoadCapabilitiesMutationResult = NonNullable<
+  Awaited<ReturnType<typeof loadCapabilities>>
+>;
+export type LoadCapabilitiesMutationBody = CapabilityPostBodyBody;
+export type LoadCapabilitiesMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Loads Capabilities against an Organisation
+ */
+export const useLoadCapabilities = <TError = ErrorType<AsError | void>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof loadCapabilities>>,
+      TError,
+      { orgId: string; data: CapabilityPostBodyBody },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof loadCapabilities>>,
+  TError,
+  { orgId: string; data: CapabilityPostBodyBody },
+  TContext
+> => {
+  return useMutation(getLoadCapabilitiesMutationOptions(options), queryClient);
+};
+export type getCapabilitiesResponse200 = { data: CapabilitiesGetResponse; status: 200 };
+
+export type getCapabilitiesResponse401 = { data: void; status: 401 };
+
+export type getCapabilitiesResponse403 = { data: AsError; status: 403 };
+
+export type getCapabilitiesResponse404 = { data: AsError; status: 404 };
+
+export type getCapabilitiesResponseSuccess = getCapabilitiesResponse200 & { headers: Headers };
+export type getCapabilitiesResponseError = (
+  | getCapabilitiesResponse401
+  | getCapabilitiesResponse403
+  | getCapabilitiesResponse404
+) & { headers: Headers };
+
+export type getCapabilitiesResponse = getCapabilitiesResponseSuccess | getCapabilitiesResponseError;
+
+export const getGetCapabilitiesUrl = (orgId: string) => {
+  return `/capability/${orgId}`;
+};
+
+/**
+ * Gets the Capabilities loaded against an Organisation.
+ *
+ * You need admin rights to use this path.
+ * @summary Gets an Organisation's Capabilities
+ */
+export const getCapabilities = async (
+  orgId: string,
+  options?: RequestInit,
+): Promise<getCapabilitiesResponse> => {
+  return customFetch<getCapabilitiesResponse>(getGetCapabilitiesUrl(orgId), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getGetCapabilitiesQueryKey = (orgId: string) => {
+  return ["account-server", "capability", orgId] as const;
+};
+
+export const getGetCapabilitiesQueryOptions = <
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetCapabilitiesQueryKey(orgId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getCapabilities>>> = ({ signal }) =>
+    getCapabilities(orgId, { signal, ...requestOptions });
+
+  return {
+    queryKey,
+    queryFn,
+    enabled: orgId !== null && orgId !== undefined,
+    ...queryOptions,
+  } as UseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+  };
+};
+
+export type GetCapabilitiesQueryResult = NonNullable<Awaited<ReturnType<typeof getCapabilities>>>;
+export type GetCapabilitiesQueryError = ErrorType<void | AsError>;
+
+export function useGetCapabilities<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>> &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getCapabilities>>,
+          TError,
+          Awaited<ReturnType<typeof getCapabilities>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetCapabilities<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>> &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getCapabilities>>,
+          TError,
+          Awaited<ReturnType<typeof getCapabilities>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetCapabilities<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+/**
+ * @summary Gets an Organisation's Capabilities
+ */
+
+export function useGetCapabilities<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>>;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = getGetCapabilitiesQueryOptions(orgId, options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+  };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+/**
+ * @summary Gets an Organisation's Capabilities
+ */
+export const invalidateGetCapabilities = async (
+  queryClient: QueryClient,
+  orgId: string,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetCapabilitiesQueryKey(orgId) }, options);
+
+  return queryClient;
+};
+
+export const getGetCapabilitiesSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetCapabilitiesQueryKey(orgId);
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getCapabilities>>> = ({ signal }) =>
+    getCapabilities(orgId, { signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getCapabilities>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type GetCapabilitiesSuspenseQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getCapabilities>>
+>;
+export type GetCapabilitiesSuspenseQueryError = ErrorType<void | AsError>;
+
+export function useGetCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options: {
+    query: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+/**
+ * @summary Gets an Organisation's Capabilities
+ */
+
+export function useGetCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  orgId: string,
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = getGetCapabilitiesSuspenseQueryOptions(orgId, options);
+
+  const query = useSuspenseQuery(queryOptions, queryClient) as UseSuspenseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+export type deleteCapabilityResponse204 = { data: void; status: 204 };
+
+export type deleteCapabilityResponse401 = { data: void; status: 401 };
+
+export type deleteCapabilityResponse403 = { data: AsError; status: 403 };
+
+export type deleteCapabilityResponse404 = { data: AsError; status: 404 };
+
+export type deleteCapabilityResponse422 = { data: AsError; status: 422 };
+
+export type deleteCapabilityResponseSuccess = deleteCapabilityResponse204 & { headers: Headers };
+export type deleteCapabilityResponseError = (
+  | deleteCapabilityResponse401
+  | deleteCapabilityResponse403
+  | deleteCapabilityResponse404
+  | deleteCapabilityResponse422
+) & { headers: Headers };
+
+export type deleteCapabilityResponse =
+  | deleteCapabilityResponseSuccess
+  | deleteCapabilityResponseError;
+
+export const getDeleteCapabilityUrl = (orgId: string, capabilityName: string) => {
+  return `/capability/${orgId}/${capabilityName}`;
+};
+
+/**
+ * Deletes a Capability from an Organisation. What else happens depends on the Capability (see the Capability catalogue).
+ *
+ * You need admin rights to use this path.
+ * @summary Deletes a Capability
+ */
+export const deleteCapability = async (
+  orgId: string,
+  capabilityName: string,
+  options?: RequestInit,
+): Promise<deleteCapabilityResponse> => {
+  return customFetch<deleteCapabilityResponse>(getDeleteCapabilityUrl(orgId, capabilityName), {
+    ...options,
+    method: "DELETE",
+  });
+};
+
+export const getDeleteCapabilityMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteCapability>>,
+    TError,
+    { orgId: string; capabilityName: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof deleteCapability>>,
+  TError,
+  { orgId: string; capabilityName: string },
+  TContext
+> => {
+  const mutationKey = ["deleteCapability"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof deleteCapability>>,
+    { orgId: string; capabilityName: string }
+  > = (props) => {
+    const { orgId, capabilityName } = props ?? {};
+
+    return deleteCapability(orgId, capabilityName, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteCapabilityMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deleteCapability>>
+>;
+
+export type DeleteCapabilityMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Deletes a Capability
+ */
+export const useDeleteCapability = <TError = ErrorType<void | AsError>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof deleteCapability>>,
+      TError,
+      { orgId: string; capabilityName: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof deleteCapability>>,
+  TError,
+  { orgId: string; capabilityName: string },
+  TContext
+> => {
+  return useMutation(getDeleteCapabilityMutationOptions(options), queryClient);
+};
+export type enableCapabilityResponse204 = { data: void; status: 204 };
+
+export type enableCapabilityResponse401 = { data: void; status: 401 };
+
+export type enableCapabilityResponse403 = { data: AsError; status: 403 };
+
+export type enableCapabilityResponse404 = { data: AsError; status: 404 };
+
+export type enableCapabilityResponse422 = { data: AsError; status: 422 };
+
+export type enableCapabilityResponseSuccess = enableCapabilityResponse204 & { headers: Headers };
+export type enableCapabilityResponseError = (
+  | enableCapabilityResponse401
+  | enableCapabilityResponse403
+  | enableCapabilityResponse404
+  | enableCapabilityResponse422
+) & { headers: Headers };
+
+export type enableCapabilityResponse =
+  | enableCapabilityResponseSuccess
+  | enableCapabilityResponseError;
+
+export const getEnableCapabilityUrl = (orgId: string, capabilityName: string) => {
+  return `/capability/${orgId}/${capabilityName}/enable`;
+};
+
+/**
+ * Enables an Organisation's Capability. An enabled Capability is available to Merchants. It is not an error to enable a Capability that is already enabled.
+ *
+ * You need admin rights to use this path.
+ * @summary Enables a Capability
+ */
+export const enableCapability = async (
+  orgId: string,
+  capabilityName: string,
+  options?: RequestInit,
+): Promise<enableCapabilityResponse> => {
+  return customFetch<enableCapabilityResponse>(getEnableCapabilityUrl(orgId, capabilityName), {
+    ...options,
+    method: "PUT",
+  });
+};
+
+export const getEnableCapabilityMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof enableCapability>>,
+    TError,
+    { orgId: string; capabilityName: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof enableCapability>>,
+  TError,
+  { orgId: string; capabilityName: string },
+  TContext
+> => {
+  const mutationKey = ["enableCapability"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof enableCapability>>,
+    { orgId: string; capabilityName: string }
+  > = (props) => {
+    const { orgId, capabilityName } = props ?? {};
+
+    return enableCapability(orgId, capabilityName, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type EnableCapabilityMutationResult = NonNullable<
+  Awaited<ReturnType<typeof enableCapability>>
+>;
+
+export type EnableCapabilityMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Enables a Capability
+ */
+export const useEnableCapability = <TError = ErrorType<void | AsError>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof enableCapability>>,
+      TError,
+      { orgId: string; capabilityName: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof enableCapability>>,
+  TError,
+  { orgId: string; capabilityName: string },
+  TContext
+> => {
+  return useMutation(getEnableCapabilityMutationOptions(options), queryClient);
+};
+export type disableCapabilityResponse204 = { data: void; status: 204 };
+
+export type disableCapabilityResponse401 = { data: void; status: 401 };
+
+export type disableCapabilityResponse403 = { data: AsError; status: 403 };
+
+export type disableCapabilityResponse404 = { data: AsError; status: 404 };
+
+export type disableCapabilityResponse422 = { data: AsError; status: 422 };
+
+export type disableCapabilityResponseSuccess = disableCapabilityResponse204 & { headers: Headers };
+export type disableCapabilityResponseError = (
+  | disableCapabilityResponse401
+  | disableCapabilityResponse403
+  | disableCapabilityResponse404
+  | disableCapabilityResponse422
+) & { headers: Headers };
+
+export type disableCapabilityResponse =
+  | disableCapabilityResponseSuccess
+  | disableCapabilityResponseError;
+
+export const getDisableCapabilityUrl = (orgId: string, capabilityName: string) => {
+  return `/capability/${orgId}/${capabilityName}/disable`;
+};
+
+/**
+ * Disables an Organisation's Capability. A disabled Capability remains loaded but has no effect. It is not an error to disable a Capability that is already disabled.
+ *
+ * You need admin rights to use this path.
+ * @summary Disables a Capability
+ */
+export const disableCapability = async (
+  orgId: string,
+  capabilityName: string,
+  options?: RequestInit,
+): Promise<disableCapabilityResponse> => {
+  return customFetch<disableCapabilityResponse>(getDisableCapabilityUrl(orgId, capabilityName), {
+    ...options,
+    method: "PUT",
+  });
+};
+
+export const getDisableCapabilityMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof disableCapability>>,
+    TError,
+    { orgId: string; capabilityName: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof disableCapability>>,
+  TError,
+  { orgId: string; capabilityName: string },
+  TContext
+> => {
+  const mutationKey = ["disableCapability"];
+  const { mutation: mutationOptions, request: requestOptions } = options
+    ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey
+      ? options
+      : { ...options, mutation: { ...options.mutation, mutationKey } }
+    : { mutation: { mutationKey }, request: undefined };
+
+  const mutationFn: MutationFunction<
+    Awaited<ReturnType<typeof disableCapability>>,
+    { orgId: string; capabilityName: string }
+  > = (props) => {
+    const { orgId, capabilityName } = props ?? {};
+
+    return disableCapability(orgId, capabilityName, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DisableCapabilityMutationResult = NonNullable<
+  Awaited<ReturnType<typeof disableCapability>>
+>;
+
+export type DisableCapabilityMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Disables a Capability
+ */
+export const useDisableCapability = <TError = ErrorType<void | AsError>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof disableCapability>>,
+      TError,
+      { orgId: string; capabilityName: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof disableCapability>>,
+  TError,
+  { orgId: string; capabilityName: string },
+  TContext
+> => {
+  return useMutation(getDisableCapabilityMutationOptions(options), queryClient);
+};