@keboola/api-client 0.1.0

package/dist/management/index.js

@@ -0,0 +1,865 @@
+import qs from 'qs';
+
+// src/errors/ApiError.ts
+var ApiError = class extends Error {
+  response;
+  request;
+  data;
+  constructor({ response, request, data }) {
+    super(response.statusText);
+    this.response = response;
+    this.request = request;
+    this.data = data;
+  }
+};
+
+// src/errors/ManagementClientAuthError.ts
+var ManagementClientAuthError = class extends ApiError {
+  title;
+  message;
+  constructor(title, message, res) {
+    super(res);
+    this.title = title;
+    this.message = message;
+  }
+};
+var HttpHeader = {
+  CONTENT_TYPE: "content-type"};
+var HttpContentType = {
+  JSON: "application/json",
+  TEXT_HTML: "text/html"
+};
+var defaultValidateStatus = ({ response }) => response.status >= 200 && response.status <= 299;
+function removeUndefined(obj) {
+  const objCopy = { ...obj };
+  for (const [key, value] of Object.entries(objCopy)) {
+    if (value == null) delete objCopy[key];
+  }
+  return objCopy;
+}
+var parseData = async (response) => {
+  if (response.status === 204) return null;
+  const contentType = response.headers.get(HttpHeader.CONTENT_TYPE);
+  if (contentType && contentType == HttpContentType.JSON) {
+    return response.json();
+  }
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var cleanHeadersInit = (headersInit) => {
+  if (Array.isArray(headersInit)) return headersInit;
+  if (headersInit instanceof Headers) return headersInit;
+  if (headersInit == null) return headersInit;
+  return removeUndefined(headersInit);
+};
+var createHeaders = (headersInitA, headersInitB) => {
+  const headersA = new Headers(cleanHeadersInit(headersInitA));
+  const headersB = new Headers(cleanHeadersInit(headersInitB));
+  headersB.forEach((value, key) => {
+    headersA.set(key, value);
+  });
+  return headersA;
+};
+var createPath = (path, pathParam = {}) => path.replace(/\{([^}]+)}/g, (_, key) => {
+  if (!(key in pathParam))
+    throw new Error(`Path parameter "${key}" is missing in the path "${path}"`);
+  return encodeURIComponent(pathParam[key]);
+});
+var createSearch = (query, options = {}) => {
+  return qs.stringify(query, {
+    encodeValuesOnly: true,
+    skipNulls: true,
+    ...options
+  });
+};
+var createBody = (body, headers) => {
+  if (body == null) return null;
+  if (body instanceof FormData) return body;
+  if (typeof body === "string") return body;
+  const stringifyBody = JSON.stringify(body);
+  const stringBody = stringifyBody === "{}" ? null : stringifyBody;
+  if (stringBody) headers.set(HttpHeader.CONTENT_TYPE, HttpContentType.JSON);
+  return stringBody;
+};
+var createFetchRequest = ({
+  url,
+  method,
+  params,
+  options = {},
+  defaultOptions
+}) => {
+  const {
+    baseUrl,
+    validateStatus: defValidateStatus = defaultValidateStatus,
+    headers: defaultHeaders,
+    ...restDefaultOptions
+  } = defaultOptions;
+  const { validateStatus, queryArrayFormat, headers: endpointHeaders, ...restOptions } = options;
+  const headers = createHeaders(defaultHeaders, endpointHeaders);
+  const path = createPath(url, params.path);
+  const search = createSearch(params.query ?? {}, { arrayFormat: queryArrayFormat });
+  const body = createBody(params.body, headers);
+  const urlInstance = new URL(baseUrl + path);
+  urlInstance.search = search;
+  const request = new Request(urlInstance, {
+    ...restDefaultOptions,
+    ...restOptions,
+    headers,
+    method: method.toUpperCase(),
+    body
+  });
+  return { request, validateStatus: validateStatus ?? defValidateStatus };
+};
+
+// src/fetchClient/createFetchClient/createFetchClient.ts
+var isApiError = (error) => error instanceof ApiError;
+var createCoreFetch = (fetchFn) => async ({ request, validateStatus }) => {
+  const response = await fetchFn(request);
+  const data = await parseData(response);
+  const apiResponse = {
+    request,
+    response,
+    data
+  };
+  const boolOrError = validateStatus(apiResponse);
+  if (isApiError(boolOrError)) throw boolOrError;
+  if (!boolOrError) throw new ApiError(apiResponse);
+  return apiResponse;
+};
+var createFetchClient = ({
+  middlewares = [],
+  ...defaultOptions
+}) => {
+  const coreFetch = createCoreFetch(defaultOptions.fetchFn ?? fetch);
+  const fetchWithMiddlewares = middlewares.reduceRight(
+    (next, middleware) => middleware(next),
+    coreFetch
+  );
+  const createFetchMethod = (method) => async (url, params, options = {}) => {
+    const request = createFetchRequest({
+      url,
+      method,
+      params,
+      defaultOptions,
+      options
+    });
+    const methodMiddlewares = options?.middlewares ?? [];
+    return methodMiddlewares.reduceRight(
+      (next, middleware) => middleware(next),
+      fetchWithMiddlewares
+    )(request);
+  };
+  return {
+    get: createFetchMethod("get"),
+    post: createFetchMethod("post"),
+    put: createFetchMethod("put"),
+    patch: createFetchMethod("patch"),
+    delete: createFetchMethod("delete")
+  };
+};
+
+// src/fetchClient/createFetchClient/middlewares.ts
+var createCallbackMiddleware = ({ onError, onSettled, onSuccess } = {}) => (next) => async (request) => {
+  let response;
+  try {
+    response = await next(request);
+    onSuccess?.();
+  } catch (error) {
+    onError?.(error);
+    throw error;
+  } finally {
+    onSettled?.();
+  }
+  return response;
+};
+
+// src/fetchClient/createGenericFetchClient.ts
+var createGenericFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
+
+// src/fetchClient/createOpenapiFetchClient.ts
+var createOpenapiFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
+
+// src/constants.ts
+var KeboolaHttpHeader = {
+  STORAGE_API_TOKEN: "X-StorageApi-Token",
+  MANAGEMENT_API_TOKEN: "X-Kbc-Manageapitoken"};
+
+// src/clients/verify/createVerifyClient.ts
+var createVerifyClient = () => {
+  const storageApiToken = async (host, token, signal) => {
+    const { data } = await createGenericFetchClient({
+      baseUrl: `${host}/v2/storage`,
+      headers: new Headers({ [KeboolaHttpHeader.STORAGE_API_TOKEN]: token })
+    }).get("/tokens/verify", {}, { signal });
+    return data;
+  };
+  const managementApiToken = async (host, token, signal) => {
+    const { data } = await createGenericFetchClient({
+      baseUrl: host,
+      headers: new Headers({ [KeboolaHttpHeader.MANAGEMENT_API_TOKEN]: token })
+    }).get("/manage/tokens/verify", {}, { signal });
+    return data;
+  };
+  return {
+    storageApiToken,
+    managementApiToken
+  };
+};
+
+// src/clients/management/authMiddleware.ts
+var isManagementClientAuthError = (error) => error instanceof ManagementClientAuthError;
+var createAuth = (baseUrl) => {
+  const fetchClient = createGenericFetchClient({ baseUrl });
+  const createCurrentUserSessionToken = async (accessToken) => {
+    const headers = new Headers({ [KeboolaHttpHeader.MANAGEMENT_API_TOKEN]: accessToken });
+    const { data } = await fetchClient.post(
+      "/manage/current-user/session-token",
+      {},
+      { headers }
+    );
+    return data.token;
+  };
+  const createAdminAccountSessionToken = async () => {
+    const { data } = await fetchClient.post(
+      "/admin/account/session-token",
+      {},
+      {
+        // transform valid response, to invalid and throw custom error
+        validateStatus: (apiResponse) => {
+          const { response } = apiResponse;
+          const isTextContent = response.headers.get(HttpHeader.CONTENT_TYPE)?.includes(HttpContentType.TEXT_HTML);
+          if (isTextContent)
+            return new ManagementClientAuthError(
+              "Your session expired",
+              "You will be logged out automatically.",
+              apiResponse
+            );
+          return defaultValidateStatus(apiResponse);
+        }
+      }
+    );
+    return data.token;
+  };
+  return {
+    createCurrentUserSessionToken,
+    createAdminAccountSessionToken
+  };
+};
+var createAuthMiddleware = ({
+  accessToken,
+  baseUrl
+}) => {
+  const auth = createAuth(baseUrl);
+  const verify = createVerifyClient();
+  let token = accessToken;
+  const isDevelopment = process.env.NODE_ENV === "development";
+  return (next) => async (request) => {
+    if (!!token) {
+      const tokenInfo = await verify.managementApiToken(baseUrl, token);
+      const isTokenValid = !tokenInfo.isDisabled && !tokenInfo.isExpired;
+      if (!isTokenValid) {
+        token = isDevelopment ? await auth.createCurrentUserSessionToken(token) : await auth.createAdminAccountSessionToken();
+      }
+    } else {
+      token = await auth.createAdminAccountSessionToken();
+    }
+    request.request.headers.set(KeboolaHttpHeader.MANAGEMENT_API_TOKEN, token);
+    return next(request);
+  };
+};
+
+// src/clients/management/currentUser/currentUser.ts
+var createCurrentUser = (client) => {
+  const getMaintainerInvitations = async (signal) => {
+    const { data } = await client.get(
+      "/manage/current-user/maintainers-invitations",
+      {},
+      { signal }
+    );
+    return data;
+  };
+  const getMaintainerInvitation = async (id, signal) => {
+    const { data } = await client.get(
+      "/manage/current-user/maintainers-invitations/{id}",
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
+  const acceptMaintainerInvitation = async (id) => {
+    await client.put("/manage/current-user/maintainers-invitations/{id}", { path: { id } });
+  };
+  const rejectMaintainerInvitation = async (id) => {
+    await client.delete("/manage/current-user/maintainers-invitations/{id}", { path: { id } });
+  };
+  const getOrganizationInvitations = async (signal) => {
+    const { data } = await client.get(
+      "/manage/current-user/organizations-invitations",
+      {},
+      { signal }
+    );
+    return data;
+  };
+  const getOrganizationInvitation = async (id, signal) => {
+    const { data } = await client.get(
+      "/manage/current-user/organizations-invitations/{id}",
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
+  const acceptOrganizationInvitation = async (id) => {
+    await client.put("/manage/current-user/organizations-invitations/{id}", { path: { id } });
+  };
+  const rejectOrganizationInvitation = async (id) => {
+    await client.delete("/manage/current-user/organizations-invitations/{id}", { path: { id } });
+  };
+  const getProjectInvitations = async (signal) => {
+    const { data } = await client.get("/manage/current-user/projects-invitations", {}, { signal });
+    return data;
+  };
+  const getProjectInvitation = async (id, signal) => {
+    const { data } = await client.get(
+      "/manage/current-user/projects-invitations/{id}",
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
+  const acceptProjectInvitation = async (id) => {
+    await client.put("/manage/current-user/projects-invitations/{id}", { path: { id } });
+  };
+  const rejectProjectInvitation = async (id) => {
+    await client.delete("/manage/current-user/projects-invitations/{id}", { path: { id } });
+  };
+  const getProjectJoinRequests = async (signal) => {
+    const { data } = await client.get(
+      "/manage/current-user/projects-join-requests",
+      {},
+      { signal }
+    );
+    return data;
+  };
+  const deleteProjectJoinRequest = async (id) => {
+    await client.delete("/manage/current-user/projects-join-requests/{id}", { path: { id } });
+  };
+  return {
+    getMaintainerInvitations,
+    getMaintainerInvitation,
+    acceptMaintainerInvitation,
+    rejectMaintainerInvitation,
+    getOrganizationInvitations,
+    getOrganizationInvitation,
+    acceptOrganizationInvitation,
+    rejectOrganizationInvitation,
+    getProjectInvitations,
+    getProjectInvitation,
+    acceptProjectInvitation,
+    rejectProjectInvitation,
+    getProjectJoinRequests,
+    deleteProjectJoinRequest
+  };
+};
+
+// src/clients/management/features/features.ts
+var createFeatures = (client) => {
+  const getAllFeatures = async (query, signal) => {
+    const { data } = await client.get(
+      "/features",
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    getAllFeatures
+  };
+};
+
+// src/clients/management/maintainers/maintainers.ts
+var createMaintainers = (client) => {
+  const getMaintainers = async (signal) => {
+    const { data } = await client.get("/manage/maintainers", {}, { signal });
+    return data;
+  };
+  const getMaintainer = async (maintainerId, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}",
+      { path: { id: maintainerId } },
+      { signal }
+    );
+    return data;
+  };
+  const createMaintainer = async (body) => {
+    const { data } = await client.post("/manage/maintainers", { body });
+    return data;
+  };
+  const updateMaintainer = async ({
+    maintainerId,
+    ...body
+  }) => {
+    const { data } = await client.patch("/manage/maintainers/{id}", {
+      path: { id: maintainerId },
+      body
+    });
+    return data;
+  };
+  const deleteMaintainer = async (maintainerId) => {
+    await client.delete("/manage/maintainers/{id}", { path: { id: maintainerId } });
+  };
+  const getMaintainerUsers = async (maintainerId, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}/users",
+      { path: { id: maintainerId } },
+      { signal }
+    );
+    return data;
+  };
+  const addMaintainerUser = async ({
+    maintainerId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/maintainers/{id}/users", {
+      path: { id: maintainerId },
+      body
+    });
+    return data;
+  };
+  const removeMaintainerUser = async ({
+    maintainerId,
+    adminId
+  }) => {
+    await client.delete("/manage/maintainers/{id}/users/{adminId}", {
+      path: { id: maintainerId, adminId }
+    });
+  };
+  const getMaintainerInvitations = async (maintainerId, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}/invitations",
+      { path: { id: maintainerId } },
+      { signal }
+    );
+    return data;
+  };
+  const getMaintainerInvitation = async ({ maintainerId, invitationId }, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}/invitations/{invitationId}",
+      { path: { id: maintainerId, invitationId } },
+      { signal }
+    );
+    return data;
+  };
+  const createMaintainerInvitation = async ({
+    maintainerId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/maintainers/{id}/invitations", {
+      path: { id: maintainerId },
+      body
+    });
+    return data;
+  };
+  const deleteMaintainerInvitation = async ({
+    maintainerId,
+    invitationId
+  }) => {
+    await client.delete("/manage/maintainers/{id}/invitations/{invitationId}", {
+      path: { id: maintainerId, invitationId }
+    });
+  };
+  const getMaintainerOrganizations = async (maintainerId, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}/organizations",
+      { path: { id: maintainerId } },
+      { signal }
+    );
+    return data;
+  };
+  const createMaintainerOrganization = async ({
+    maintainerId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/maintainers/{id}/organizations", {
+      path: { id: maintainerId },
+      body
+    });
+    return data;
+  };
+  const getMaintainerMetadata = async (maintainerId, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}/metadata",
+      { path: { id: maintainerId } },
+      { signal }
+    );
+    return data;
+  };
+  const setMaintainerMetadata = async ({
+    maintainerId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/maintainers/{id}/metadata", {
+      path: { id: maintainerId },
+      body
+    });
+    return data;
+  };
+  const deleteMaintainerMetadata = async ({
+    maintainerId,
+    metadataId
+  }) => {
+    await client.delete("/manage/maintainers/{id}/metadata/{metadataId}", {
+      path: { id: maintainerId, metadataId }
+    });
+  };
+  return {
+    getMaintainers,
+    getMaintainer,
+    createMaintainer,
+    updateMaintainer,
+    deleteMaintainer,
+    getMaintainerUsers,
+    addMaintainerUser,
+    removeMaintainerUser,
+    getMaintainerInvitations,
+    getMaintainerInvitation,
+    createMaintainerInvitation,
+    deleteMaintainerInvitation,
+    getMaintainerOrganizations,
+    createMaintainerOrganization,
+    getMaintainerMetadata,
+    setMaintainerMetadata,
+    deleteMaintainerMetadata
+  };
+};
+
+// src/clients/management/organizations/organizations.ts
+var createOrganizations = (client) => {
+  const getOrganizations = async (signal) => {
+    const { data } = await client.get("/manage/organizations", {}, { signal });
+    return data;
+  };
+  const getOrganization = async (organizationId, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}",
+      { path: { id: organizationId } },
+      { signal }
+    );
+    return data;
+  };
+  const updateOrganization = async ({
+    organizationId,
+    ...body
+  }) => {
+    const { data } = await client.patch("/manage/organizations/{id}", {
+      path: { id: organizationId },
+      body
+    });
+    return data;
+  };
+  const deleteOrganization = async (organizationId) => {
+    await client.delete("/manage/organizations/{id}", { path: { id: organizationId } });
+  };
+  const forceMfa = async (organizationId) => {
+    const { data } = await client.patch("/manage/organizations/{id}/force-mfa", {
+      path: { id: organizationId }
+    });
+    return data;
+  };
+  const joinOrganization = async (organizationId) => {
+    await client.post("/manage/organizations/{id}/join-organization", {
+      path: { id: organizationId }
+    });
+  };
+  const getOrganizationUsers = async (organizationId, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}/users",
+      { path: { id: organizationId } },
+      { signal }
+    );
+    return data;
+  };
+  const addOrganizationUser = async ({
+    organizationId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/organizations/{id}/users", {
+      path: { id: organizationId },
+      body
+    });
+    return data;
+  };
+  const removeOrganizationUser = async ({
+    organizationId,
+    userId
+  }) => {
+    await client.delete("/manage/organizations/{id}/users/{userId}", {
+      path: { id: organizationId, userId }
+    });
+  };
+  const getOrganizationProjectsUsers = async (organizationId, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}/projects-users",
+      { path: { id: organizationId } },
+      { signal }
+    );
+    return data;
+  };
+  const getOrganizationInvitations = async (organizationId, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}/invitations",
+      { path: { id: organizationId } },
+      { signal }
+    );
+    return data;
+  };
+  const getOrganizationInvitation = async ({ organizationId, invitationId }, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}/invitations/{invitationId}",
+      { path: { id: organizationId, invitationId } },
+      { signal }
+    );
+    return data;
+  };
+  const createOrganizationInvitation = async ({
+    organizationId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/organizations/{id}/invitations", {
+      path: { id: organizationId },
+      body
+    });
+    return data;
+  };
+  const deleteOrganizationInvitation = async ({
+    organizationId,
+    invitationId
+  }) => {
+    await client.delete("/manage/organizations/{id}/invitations/{invitationId}", {
+      path: { id: organizationId, invitationId }
+    });
+  };
+  const getOrganizationProjects = async (organizationId, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}/projects",
+      { path: { id: organizationId } },
+      { signal }
+    );
+    return data;
+  };
+  const createOrganizationProject = async ({
+    organizationId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/organizations/{id}/projects", {
+      path: { id: organizationId },
+      body
+    });
+    return data;
+  };
+  const getOrganizationMetadata = async (organizationId, signal) => {
+    const { data } = await client.get(
+      "/manage/organizations/{id}/metadata",
+      { path: { id: organizationId } },
+      { signal }
+    );
+    return data;
+  };
+  const setOrganizationMetadata = async ({
+    organizationId,
+    ...body
+  }) => {
+    const { data } = await client.post("/manage/organizations/{id}/metadata", {
+      path: { id: organizationId },
+      body
+    });
+    return data;
+  };
+  const deleteOrganizationMetadata = async ({
+    organizationId,
+    metadataId
+  }) => {
+    await client.delete("/manage/organizations/{id}/metadata/{metadataId}", {
+      path: { id: organizationId, metadataId }
+    });
+  };
+  return {
+    getOrganizations,
+    getOrganization,
+    updateOrganization,
+    deleteOrganization,
+    forceMfa,
+    joinOrganization,
+    getOrganizationUsers,
+    addOrganizationUser,
+    removeOrganizationUser,
+    getOrganizationProjectsUsers,
+    getOrganizationInvitations,
+    getOrganizationInvitation,
+    createOrganizationInvitation,
+    deleteOrganizationInvitation,
+    getOrganizationProjects,
+    createOrganizationProject,
+    getOrganizationMetadata,
+    setOrganizationMetadata,
+    deleteOrganizationMetadata
+  };
+};
+
+// src/clients/management/projects/projects.ts
+var createProjects = (client) => {
+  const getProject = async (projectId, signal) => {
+    const { data } = await client.get(
+      "/projects/{projectId}",
+      { path: { projectId } },
+      { signal }
+    );
+    return data;
+  };
+  const addProjectFeature = async ({
+    projectId,
+    feature
+  }) => {
+    const { data } = await client.post("/projects/{projectId}/features", { path: { projectId }, body: { feature } });
+    return data;
+  };
+  const removeProjectFeature = async (path) => {
+    const { data } = await client.delete(
+      "/projects/{projectId}/features/{feature}",
+      { path }
+    );
+    return data;
+  };
+  const changeProjectUserRole = async ({
+    projectId,
+    userId,
+    role
+  }) => {
+    const { data } = await client.patch("/projects/{projectId}/users/{userId}", {
+      path: { projectId, userId },
+      body: { role }
+    });
+    return data;
+  };
+  const getProjectUsers = async (projectId, signal) => {
+    const { data } = await client.get(
+      "/projects/{projectId}/users",
+      { path: { projectId } },
+      { signal }
+    );
+    return data;
+  };
+  const getProjectMetadata = async (projectId, signal) => {
+    const { data } = await client.get(
+      "/projects/{projectId}/metadata",
+      { path: { projectId } },
+      { signal }
+    );
+    return data;
+  };
+  const setProjectMetadata = async ({
+    projectId,
+    provider,
+    metadata
+  }) => {
+    const { data } = await client.post("/projects/{projectId}/metadata", {
+      path: { projectId },
+      body: { provider, metadata }
+    });
+    return data;
+  };
+  const getProjectReviewers = async (projectId, signal) => {
+    const { data } = await client.get(
+      "/projects/{projectId}/reviewers",
+      { path: { projectId } },
+      { signal }
+    );
+    return data;
+  };
+  const setProjectReviewers = async ({
+    projectId,
+    adminIds
+  }) => {
+    const { data } = await client.put("/projects/{projectId}/reviewers", {
+      path: { projectId },
+      body: { adminIds }
+    });
+    return data;
+  };
+  return {
+    getProject,
+    addProjectFeature,
+    removeProjectFeature,
+    changeProjectUserRole,
+    getProjectUsers,
+    getProjectMetadata,
+    setProjectMetadata,
+    getProjectReviewers,
+    setProjectReviewers
+  };
+};
+
+// src/clients/management/users/users.ts
+var createUsers = (client) => {
+  const addUserAdminFeature = async ({ feature, userIdOrMail }, signal) => {
+    const { data } = await client.post(
+      "/users/{userIdOrMail}/features",
+      { path: { userIdOrMail: encodeURIComponent(userIdOrMail) }, body: { feature } },
+      { signal }
+    );
+    return data;
+  };
+  const removeUserAdminFeature = async ({ userIdOrMail, feature }, signal) => {
+    const { data } = await client.delete(
+      "/users/{userIdOrMail}/features/{feature}",
+      { path: { userIdOrMail: encodeURIComponent(userIdOrMail), feature } },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    addUserAdminFeature,
+    removeUserAdminFeature
+  };
+};
+
+// src/clients/management/managementClient.ts
+var createManagementClient = ({
+  baseUrl,
+  callbacks,
+  token
+}) => {
+  const callbackMiddleware = createCallbackMiddleware(callbacks);
+  const authMiddleware = createAuthMiddleware({
+    baseUrl,
+    accessToken: token
+  });
+  const middlewares = [
+    callbackMiddleware,
+    authMiddleware
+    // 👈  beware order of middlewares always matter
+  ];
+  const client = createGenericFetchClient({
+    baseUrl: `${baseUrl}/manage`,
+    middlewares
+  });
+  const openApiClient = createOpenapiFetchClient({
+    baseUrl,
+    middlewares
+  });
+  return {
+    currentUser: createCurrentUser(openApiClient),
+    features: createFeatures(client),
+    maintainers: createMaintainers(openApiClient),
+    organizations: createOrganizations(openApiClient),
+    projects: createProjects(client),
+    users: createUsers(client)
+  };
+};
+
+export { createManagementClient, isManagementClientAuthError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map