@squonk/account-server-client 4.9.0 → 4.10.0

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

@@ -6,7 +6,7 @@
  *
  * 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
+ * OpenAPI spec version: 4.10
  */
 import { useMutation, useQuery, useSuspenseQuery } from "@tanstack/react-query";
 import type {
@@ -33,6 +33,7 @@ import type {
   CapabilitiesGetResponse,
   CapabilityPostBodyBody,
   CapabilityPostResponse,
+  DefaultCapabilitiesGetResponse,
 } from "../api-schemas";
 
 import { customFetch } from "../../custom-fetch";
@@ -78,7 +79,7 @@ export const getGetAllCapabilitiesUrl = () => {
 };
 
 /**
- * Gets the Capabilities of all the Organisations, indexed by Organisation. Organisations without Capabilities are not included.
+ * Gets the Capabilities of all the Organisations, indexed by Organisation. Organisations without Capabilities are not included. The response also lists the Default Capabilities, which every Organisation has.
  *
  * You need admin rights to use this path.
  * @summary Gets the Capabilities of all Organisations
@@ -676,6 +677,8 @@ export type deleteCapabilityResponse403 = { data: AsError; status: 403 };
 
 export type deleteCapabilityResponse404 = { data: AsError; status: 404 };
 
+export type deleteCapabilityResponse409 = { data: AsError; status: 409 };
+
 export type deleteCapabilityResponse422 = { data: AsError; status: 422 };
 
 export type deleteCapabilityResponseSuccess = deleteCapabilityResponse204 & { headers: Headers };
@@ -683,6 +686,7 @@ export type deleteCapabilityResponseError = (
   | deleteCapabilityResponse401
   | deleteCapabilityResponse403
   | deleteCapabilityResponse404
+  | deleteCapabilityResponse409
   | deleteCapabilityResponse422
 ) & { headers: Headers };
 
@@ -695,7 +699,7 @@ export const getDeleteCapabilityUrl = (orgId: string, capabilityName: string) =>
 };
 
 /**
- * Deletes a Capability from an Organisation. What else happens depends on the Capability (see the Capability catalogue).
+ * Deletes a Capability from an Organisation. What else happens depends on the Capability (see the Capability catalogue). A Default Capability cannot be deleted from one Organisation (it can be disabled).
  *
  * You need admin rights to use this path.
  * @summary Deletes a Capability
@@ -775,6 +779,482 @@ export const useDeleteCapability = <TError = ErrorType<void | AsError>, TContext
 > => {
   return useMutation(getDeleteCapabilityMutationOptions(options), queryClient);
 };
+export type loadDefaultCapabilitiesResponse201 = { data: CapabilityPostResponse; status: 201 };
+
+export type loadDefaultCapabilitiesResponse400 = { data: AsError; status: 400 };
+
+export type loadDefaultCapabilitiesResponse401 = { data: void; status: 401 };
+
+export type loadDefaultCapabilitiesResponse403 = { data: AsError; status: 403 };
+
+export type loadDefaultCapabilitiesResponse409 = { data: AsError; status: 409 };
+
+export type loadDefaultCapabilitiesResponse422 = { data: AsError; status: 422 };
+
+export type loadDefaultCapabilitiesResponseSuccess = loadDefaultCapabilitiesResponse201 & {
+  headers: Headers;
+};
+export type loadDefaultCapabilitiesResponseError = (
+  | loadDefaultCapabilitiesResponse400
+  | loadDefaultCapabilitiesResponse401
+  | loadDefaultCapabilitiesResponse403
+  | loadDefaultCapabilitiesResponse409
+  | loadDefaultCapabilitiesResponse422
+) & { headers: Headers };
+
+export type loadDefaultCapabilitiesResponse =
+  | loadDefaultCapabilitiesResponseSuccess
+  | loadDefaultCapabilitiesResponseError;
+
+export const getLoadDefaultCapabilitiesUrl = () => {
+  return `/default-capability`;
+};
+
+/**
+ * Loads the Capabilities defined in a YAML file as Default Capabilities. A Default Capability is loaded against every Organisation, and against every Organisation that is created later. Either all the Capabilities in the file are loaded (against every Organisation) or none of them are.
+ *
+ * A Default Capability cannot have the name of another Default Capability, or the name of a Capability that an Organisation has. Some Capabilities cannot be Default Capabilities (for example **viz**, because each Organisation needs its own choice of data-centre server and limits). It is enabled for every Organisation when it's loaded, and it can be enabled and disabled for each Organisation.
+ *
+ * You need admin rights to use this path.
+ * @summary Loads Default Capabilities
+ */
+export const loadDefaultCapabilities = async (
+  capabilityPostBodyBody: CapabilityPostBodyBody,
+  options?: RequestInit,
+): Promise<loadDefaultCapabilitiesResponse> => {
+  const formData = new FormData();
+  formData.append(`capability_file`, capabilityPostBodyBody.capability_file);
+
+  return customFetch<loadDefaultCapabilitiesResponse>(getLoadDefaultCapabilitiesUrl(), {
+    ...options,
+    method: "POST",
+    body: formData,
+  });
+};
+
+export const getLoadDefaultCapabilitiesMutationOptions = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof loadDefaultCapabilities>>,
+    TError,
+    { data: CapabilityPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof loadDefaultCapabilities>>,
+  TError,
+  { data: CapabilityPostBodyBody },
+  TContext
+> => {
+  const mutationKey = ["loadDefaultCapabilities"];
+  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 loadDefaultCapabilities>>,
+    { data: CapabilityPostBodyBody }
+  > = (props) => {
+    const { data } = props ?? {};
+
+    return loadDefaultCapabilities(data, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type LoadDefaultCapabilitiesMutationResult = NonNullable<
+  Awaited<ReturnType<typeof loadDefaultCapabilities>>
+>;
+export type LoadDefaultCapabilitiesMutationBody = CapabilityPostBodyBody;
+export type LoadDefaultCapabilitiesMutationError = ErrorType<AsError | void>;
+
+/**
+ * @summary Loads Default Capabilities
+ */
+export const useLoadDefaultCapabilities = <TError = ErrorType<AsError | void>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof loadDefaultCapabilities>>,
+      TError,
+      { data: CapabilityPostBodyBody },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof loadDefaultCapabilities>>,
+  TError,
+  { data: CapabilityPostBodyBody },
+  TContext
+> => {
+  return useMutation(getLoadDefaultCapabilitiesMutationOptions(options), queryClient);
+};
+export type getDefaultCapabilitiesResponse200 = {
+  data: DefaultCapabilitiesGetResponse;
+  status: 200;
+};
+
+export type getDefaultCapabilitiesResponse401 = { data: void; status: 401 };
+
+export type getDefaultCapabilitiesResponse403 = { data: AsError; status: 403 };
+
+export type getDefaultCapabilitiesResponseSuccess = getDefaultCapabilitiesResponse200 & {
+  headers: Headers;
+};
+export type getDefaultCapabilitiesResponseError = (
+  | getDefaultCapabilitiesResponse401
+  | getDefaultCapabilitiesResponse403
+) & { headers: Headers };
+
+export type getDefaultCapabilitiesResponse =
+  | getDefaultCapabilitiesResponseSuccess
+  | getDefaultCapabilitiesResponseError;
+
+export const getGetDefaultCapabilitiesUrl = () => {
+  return `/default-capability`;
+};
+
+/**
+ * Gets the Default Capabilities.
+ *
+ * You need admin rights to use this path.
+ * @summary Gets the Default Capabilities
+ */
+export const getDefaultCapabilities = async (
+  options?: RequestInit,
+): Promise<getDefaultCapabilitiesResponse> => {
+  return customFetch<getDefaultCapabilitiesResponse>(getGetDefaultCapabilitiesUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
+
+export const getGetDefaultCapabilitiesQueryKey = () => {
+  return ["account-server", "default-capability"] as const;
+};
+
+export const getGetDefaultCapabilitiesQueryOptions = <
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(options?: {
+  query?: Partial<
+    UseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetDefaultCapabilitiesQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getDefaultCapabilities>>> = ({ signal }) =>
+    getDefaultCapabilities({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+    Awaited<ReturnType<typeof getDefaultCapabilities>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type GetDefaultCapabilitiesQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getDefaultCapabilities>>
+>;
+export type GetDefaultCapabilitiesQueryError = ErrorType<void | AsError>;
+
+export function useGetDefaultCapabilities<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options: {
+    query: Partial<
+      UseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    > &
+      Pick<
+        DefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getDefaultCapabilities>>,
+          TError,
+          Awaited<ReturnType<typeof getDefaultCapabilities>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetDefaultCapabilities<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    > &
+      Pick<
+        UndefinedInitialDataOptions<
+          Awaited<ReturnType<typeof getDefaultCapabilities>>,
+          TError,
+          Awaited<ReturnType<typeof getDefaultCapabilities>>
+        >,
+        "initialData"
+      >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetDefaultCapabilities<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+/**
+ * @summary Gets the Default Capabilities
+ */
+
+export function useGetDefaultCapabilities<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options?: {
+    query?: Partial<
+      UseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = getGetDefaultCapabilitiesQueryOptions(options);
+
+  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+  };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+/**
+ * @summary Gets the Default Capabilities
+ */
+export const invalidateGetDefaultCapabilities = async (
+  queryClient: QueryClient,
+  options?: InvalidateOptions,
+): Promise<QueryClient> => {
+  await queryClient.invalidateQueries({ queryKey: getGetDefaultCapabilitiesQueryKey() }, options);
+
+  return queryClient;
+};
+
+export const getGetDefaultCapabilitiesSuspenseQueryOptions = <
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(options?: {
+  query?: Partial<
+    UseSuspenseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetDefaultCapabilitiesQueryKey();
+
+  const queryFn: QueryFunction<Awaited<ReturnType<typeof getDefaultCapabilities>>> = ({ signal }) =>
+    getDefaultCapabilities({ signal, ...requestOptions });
+
+  return { queryKey, queryFn, ...queryOptions } as UseSuspenseQueryOptions<
+    Awaited<ReturnType<typeof getDefaultCapabilities>>,
+    TError,
+    TData
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+};
+
+export type GetDefaultCapabilitiesSuspenseQueryResult = NonNullable<
+  Awaited<ReturnType<typeof getDefaultCapabilities>>
+>;
+export type GetDefaultCapabilitiesSuspenseQueryError = ErrorType<void | AsError>;
+
+export function useGetDefaultCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options: {
+    query: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetDefaultCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+export function useGetDefaultCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> };
+/**
+ * @summary Gets the Default Capabilities
+ */
+
+export function useGetDefaultCapabilitiesSuspense<
+  TData = Awaited<ReturnType<typeof getDefaultCapabilities>>,
+  TError = ErrorType<void | AsError>,
+>(
+  options?: {
+    query?: Partial<
+      UseSuspenseQueryOptions<Awaited<ReturnType<typeof getDefaultCapabilities>>, TError, TData>
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseSuspenseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
+  const queryOptions = getGetDefaultCapabilitiesSuspenseQueryOptions(options);
+
+  const query = useSuspenseQuery(queryOptions, queryClient) as UseSuspenseQueryResult<
+    TData,
+    TError
+  > & { queryKey: DataTag<QueryKey, TData, TError> };
+
+  return withQueryKey(query, queryOptions.queryKey);
+}
+
+export type deleteDefaultCapabilityResponse204 = { data: void; status: 204 };
+
+export type deleteDefaultCapabilityResponse401 = { data: void; status: 401 };
+
+export type deleteDefaultCapabilityResponse403 = { data: AsError; status: 403 };
+
+export type deleteDefaultCapabilityResponse404 = { data: AsError; status: 404 };
+
+export type deleteDefaultCapabilityResponse422 = { data: AsError; status: 422 };
+
+export type deleteDefaultCapabilityResponseSuccess = deleteDefaultCapabilityResponse204 & {
+  headers: Headers;
+};
+export type deleteDefaultCapabilityResponseError = (
+  | deleteDefaultCapabilityResponse401
+  | deleteDefaultCapabilityResponse403
+  | deleteDefaultCapabilityResponse404
+  | deleteDefaultCapabilityResponse422
+) & { headers: Headers };
+
+export type deleteDefaultCapabilityResponse =
+  | deleteDefaultCapabilityResponseSuccess
+  | deleteDefaultCapabilityResponseError;
+
+export const getDeleteDefaultCapabilityUrl = (capabilityName: string) => {
+  return `/default-capability/${capabilityName}`;
+};
+
+/**
+ * Deletes a Default Capability, deleting it from every Organisation. What else happens depends on the Capability (see the Capability catalogue). If it cannot be deleted from an Organisation the Default Capability is not deleted, but it stays deleted from the Organisations it was deleted from, and the deletion can be tried again.
+ *
+ * You need admin rights to use this path.
+ * @summary Deletes a Default Capability
+ */
+export const deleteDefaultCapability = async (
+  capabilityName: string,
+  options?: RequestInit,
+): Promise<deleteDefaultCapabilityResponse> => {
+  return customFetch<deleteDefaultCapabilityResponse>(
+    getDeleteDefaultCapabilityUrl(capabilityName),
+    { ...options, method: "DELETE" },
+  );
+};
+
+export const getDeleteDefaultCapabilityMutationOptions = <
+  TError = ErrorType<void | AsError>,
+  TContext = unknown,
+>(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof deleteDefaultCapability>>,
+    TError,
+    { capabilityName: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customFetch>;
+}): UseMutationOptions<
+  Awaited<ReturnType<typeof deleteDefaultCapability>>,
+  TError,
+  { capabilityName: string },
+  TContext
+> => {
+  const mutationKey = ["deleteDefaultCapability"];
+  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 deleteDefaultCapability>>,
+    { capabilityName: string }
+  > = (props) => {
+    const { capabilityName } = props ?? {};
+
+    return deleteDefaultCapability(capabilityName, requestOptions);
+  };
+
+  return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteDefaultCapabilityMutationResult = NonNullable<
+  Awaited<ReturnType<typeof deleteDefaultCapability>>
+>;
+
+export type DeleteDefaultCapabilityMutationError = ErrorType<void | AsError>;
+
+/**
+ * @summary Deletes a Default Capability
+ */
+export const useDeleteDefaultCapability = <TError = ErrorType<void | AsError>, TContext = unknown>(
+  options?: {
+    mutation?: UseMutationOptions<
+      Awaited<ReturnType<typeof deleteDefaultCapability>>,
+      TError,
+      { capabilityName: string },
+      TContext
+    >;
+    request?: SecondParameter<typeof customFetch>;
+  },
+  queryClient?: QueryClient,
+): UseMutationResult<
+  Awaited<ReturnType<typeof deleteDefaultCapability>>,
+  TError,
+  { capabilityName: string },
+  TContext
+> => {
+  return useMutation(getDeleteDefaultCapabilityMutationOptions(options), queryClient);
+};
 export type enableCapabilityResponse204 = { data: void; status: 204 };
 
 export type enableCapabilityResponse401 = { data: void; status: 401 };