@plone/client/dist/index.js

JavaScript Plone REST API client - JS framework agnostic library based on TanStack Query

// src/API.ts
import axios from "axios";
import qs from "query-string";
import debugFactory from "debug";
var debug = debugFactory("axios");
function getBackendURL(apiPath, path) {
  const APISUFIX = "/++api++";
  if (path.startsWith("http://") || path.startsWith("https://")) return path;
  const adjustedPath = path[0] !== "/" ? `/${path}` : path;
  return `${apiPath}${APISUFIX}${adjustedPath}`;
}
var _handleResponse = ({ data }) => data;
var _handleError = (error) => {
  debug(error);
  return Promise.reject(error);
};
function axiosConfigAdapter(method, path, options) {
  const {
    config,
    params,
    data,
    type,
    headers = {},
    checkUrl = false
  } = options;
  const axiosConfig = {
    method,
    url: getBackendURL(config.apiPath, path),
    params,
    headers: {
      Accept: "application/json",
      ...headers
    },
    data,
    validateStatus: function(status) {
      return status >= 200 && status < 300;
    },
    paramsSerializer: function(params2) {
      return qs.stringify(params2, { arrayFormat: "colon-list-separator" });
    }
  };
  if (config.token && axiosConfig.headers) {
    axiosConfig.headers["Authorization"] = `Bearer ${config.token}`;
  }
  debug(axiosConfig);
  return axiosConfig;
}
async function apiRequest(method, path, options) {
  const instance = axios.create();
  if (options.raw) {
    instance.interceptors.response.use(void 0, _handleError);
  } else {
    instance.interceptors.response.use(_handleResponse, _handleError);
  }
  return instance.request(axiosConfigAdapter(method, path, options));
}

// src/restapi/login/post.ts
import { z as z2 } from "zod";

// src/validation/config.ts
import { z } from "zod";
var PloneClientConfigSchema = z.object({
  apiPath: z.string(),
  token: z.string().optional()
});

// src/restapi/login/post.ts
var loginArgsSchema = z2.object({
  username: z2.string(),
  password: z2.string(),
  config: PloneClientConfigSchema
});
var login = ({
  username,
  password,
  config
}) => {
  const validatedArgs = loginArgsSchema.parse({
    username,
    password,
    config
  });
  const options = {
    data: {
      login: validatedArgs.username,
      password: validatedArgs.password
    },
    config: validatedArgs.config
  };
  return apiRequest("post", "/@login", options);
};
var loginMutation = ({ config }) => ({
  mutationKey: ["login"],
  mutationFn: ({ username, password }) => login({ username, password, config })
});

// src/restapi/content/get.ts
import { z as z3 } from "zod";
var getContentArgsSchema = z3.object({
  path: z3.string(),
  version: z3.string().optional(),
  page: z3.number().optional(),
  fullObjects: z3.boolean().optional(),
  expand: z3.string().array().optional()
});
var getContent = async ({
  path,
  version,
  page,
  fullObjects,
  expand,
  config
}) => {
  const validatedArgs = getContentArgsSchema.parse({
    path,
    version,
    page,
    fullObjects,
    expand
  });
  const options = {
    config,
    params: {
      ...validatedArgs.page && { page: validatedArgs.page },
      ...validatedArgs.version && { version: validatedArgs.version },
      ...validatedArgs.fullObjects && {
        fullobjects: validatedArgs.fullObjects
      }
    }
  };
  if (validatedArgs.version) {
    return apiRequest(
      "get",
      `${path}/@history/${validatedArgs.version}`,
      options
    );
  }
  if (validatedArgs.expand) {
    options.params = {
      ...options.params,
      expand
    };
  }
  return apiRequest("get", path, options);
};
var getContentQuery = ({
  path,
  version,
  page,
  fullObjects,
  expand,
  config
}) => ({
  queryKey: [path, "get", "content"],
  queryFn: () => getContent({ path, expand, version, page, fullObjects, config })
});

// src/restapi/content/add.ts
import { z as z5 } from "zod";

// src/validation/content.ts
import { z as z4 } from "zod";
var RelatedItemPayloadSchema = z4.object({
  "@id": z4.string(),
  "@type": z4.string(),
  CreationDate: z4.string(),
  Creator: z4.string(),
  Date: z4.string(),
  Description: z4.string(),
  EffectiveDate: z4.unknown(),
  ExpirationDate: z4.unknown(),
  ModificationDate: z4.string(),
  Subject: z4.array(z4.unknown()),
  Title: z4.string(),
  Type: z4.string(),
  UID: z4.string(),
  author_name: z4.unknown(),
  cmf_uid: z4.unknown(),
  commentators: z4.array(z4.unknown()),
  created: z4.string(),
  description: z4.string(),
  effective: z4.string(),
  end: z4.unknown(),
  exclude_from_nav: z4.boolean(),
  expires: z4.string(),
  getIcon: z4.unknown(),
  getId: z4.string(),
  getObjSize: z4.string(),
  getPath: z4.string(),
  getRemoteUrl: z4.unknown(),
  getURL: z4.string(),
  hasPreviewImage: z4.unknown(),
  head_title: z4.unknown(),
  id: z4.string(),
  image_field: z4.string().nullable(),
  image_scales: z4.unknown(),
  in_response_to: z4.unknown(),
  is_folderish: z4.boolean(),
  last_comment_date: z4.unknown(),
  listCreators: z4.array(z4.string()),
  location: z4.unknown(),
  mime_type: z4.string(),
  modified: z4.string(),
  nav_title: z4.unknown(),
  portal_type: z4.string(),
  review_state: z4.string(),
  start: z4.unknown(),
  sync_uid: z4.unknown(),
  title: z4.string(),
  total_comments: z4.number()
});
var createContentDataSchema = z4.object({
  "@id": z4.string().optional(),
  "@static_behaviors": z4.unknown().optional(),
  "@type": z4.string(),
  allow_discussion: z4.boolean().optional(),
  blocks: z4.unknown().optional(),
  blocks_layout: z4.array(z4.string()).optional(),
  contributors: z4.array(z4.string()).optional(),
  creators: z4.array(z4.string()).optional(),
  description: z4.string().optional(),
  effective: z4.string().nullable().optional(),
  exclude_from_nav: z4.boolean().optional(),
  expires: z4.string().nullable().optional(),
  id: z4.string().optional(),
  language: z4.string().optional(),
  preview_caption: z4.string().optional(),
  preview_image: z4.object({
    "content-type": z4.string(),
    data: z4.string(),
    encoding: z4.string(),
    filename: z4.string()
  }).optional(),
  relatedItems: z4.array(RelatedItemPayloadSchema).optional(),
  rights: z4.string().nullable().optional(),
  title: z4.string(),
  versioning_enabled: z4.boolean().optional()
});
var updateContentDataSchema = z4.object({
  allow_discussion: z4.boolean().optional(),
  blocks: z4.unknown().optional(),
  blocks_layout: z4.array(z4.string()).optional(),
  contributors: z4.array(z4.string()).optional(),
  creators: z4.array(z4.string()).optional(),
  description: z4.string().optional(),
  effective: z4.string().nullable().optional(),
  exclude_from_nav: z4.boolean().optional(),
  expires: z4.string().nullable().optional(),
  id: z4.string().nullable().optional(),
  preview_caption: z4.string().optional(),
  preview_image: z4.object({
    "content-type": z4.string(),
    data: z4.string(),
    encoding: z4.string(),
    filename: z4.string()
  }).optional(),
  relatedItems: z4.array(RelatedItemPayloadSchema).optional(),
  rights: z4.string().optional(),
  table_of_contents: z4.boolean().nullable().optional(),
  title: z4.string().optional(),
  versioning_enabled: z4.boolean().optional()
});

// src/restapi/content/add.ts
var createContentArgsSchema = z5.object({
  path: z5.string(),
  data: createContentDataSchema,
  config: PloneClientConfigSchema
});
var createContent = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = createContentArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", validatedArgs.path, options);
};
var createContentMutation = ({
  config
}) => ({
  mutationKey: ["post", "content"],
  mutationFn: ({ path, data }) => createContent({ path, data, config })
});

// src/restapi/content/update.ts
import { z as z6 } from "zod";
var updateContentArgsSchema = z6.object({
  path: z6.string(),
  data: updateContentDataSchema,
  config: PloneClientConfigSchema
});
var updateContent = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = updateContentArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("patch", validatedArgs.path, options);
};
var updateContentMutation = ({
  config
}) => ({
  mutationKey: ["patch", "content"],
  mutationFn: ({ path, data }) => updateContent({ path, data, config })
});

// src/restapi/content/delete.ts
import { z as z7 } from "zod";
var deleteContentArgsSchema = z7.object({
  path: z7.string(),
  config: PloneClientConfigSchema
});
var deleteContent = async ({
  path,
  config
}) => {
  const validatedArgs = deleteContentArgsSchema.parse({
    path,
    config
  });
  const options = {
    config: validatedArgs.config
  };
  return apiRequest("delete", validatedArgs.path, options);
};
var deleteContentMutation = ({
  config
}) => ({
  mutationKey: ["delete", "content"],
  mutationFn: ({ path }) => deleteContent({ path, config })
});

// src/restapi/breadcrumbs/get.ts
import { z as z8 } from "zod";
var getBreadcrumbsSchema = z8.object({
  path: z8.string()
});
var getBreadcrumbs = async ({
  path,
  config
}) => {
  const validatedArgs = getBreadcrumbsSchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const breadcrumbsPath = `${validatedArgs.path}/@breadcrumbs`;
  return apiRequest("get", breadcrumbsPath, options);
};
var getBreadcrumbsQuery = ({ path, config }) => ({
  queryKey: [path, "get", "breadcrumbs"],
  queryFn: () => getBreadcrumbs({ path, config })
});

// src/restapi/navigation/get.ts
import { z as z9 } from "zod";
var getNavigationSchema = z9.object({
  path: z9.string(),
  depth: z9.number().optional()
});
var getNavigation = async ({
  path,
  depth,
  config
}) => {
  const validatedArgs = getNavigationSchema.parse({
    path,
    depth
  });
  const options = {
    config,
    params: {}
  };
  const navigationPath = `${validatedArgs.path}/@navigation`;
  if (validatedArgs.depth) {
    options.params["expand.navigation.depth"] = validatedArgs.depth;
  }
  return apiRequest("get", navigationPath, options);
};
var getNavigationQuery = ({
  path,
  depth,
  config
}) => ({
  queryKey: [path, depth, "get", "navigation"],
  queryFn: () => getNavigation({ path, depth, config })
});

// src/restapi/contextnavigation/get.ts
import { z as z10 } from "zod";
var getContextNavigationSchema = z10.object({
  path: z10.string()
});
var getContextNavigation = async ({
  path,
  config
}) => {
  const validatedArgs = getContextNavigationSchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const contextnavigationPath = `${validatedArgs.path}/@contextnavigation`;
  return apiRequest("get", contextnavigationPath, options);
};
var getContextNavigationQuery = ({
  path,
  config
}) => ({
  queryKey: [path, "get", "contextnavigation"],
  queryFn: () => getContextNavigation({ path, config })
});

// src/restapi/actions/get.ts
import { z as z11 } from "zod";
var getActionsSchema = z11.object({
  path: z11.string()
});
var getActions = async ({
  path,
  config
}) => {
  const validatedArgs = getActionsSchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const actionsPath = `${validatedArgs.path}/@actions`;
  return apiRequest("get", actionsPath, options);
};
var getActionsQuery = ({ path, config }) => ({
  queryKey: [path, "get", "actions"],
  queryFn: () => getActions({ path, config })
});

// src/restapi/aliases/get.ts
import { z as z12 } from "zod";
var getAliasesSchema = z12.object({
  path: z12.string()
});
var getAliases = async ({
  path,
  config
}) => {
  const validatedArgs = getAliasesSchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const aliasesPath = `${validatedArgs.path}/@aliases`;
  return apiRequest("get", aliasesPath, options);
};
var getAliasesQuery = ({ path, config }) => ({
  queryKey: [path, "get", "aliases"],
  queryFn: () => getAliases({ path, config })
});

// src/restapi/aliases/add.ts
import { z as z14 } from "zod";

// src/validation/aliases.ts
import { z as z13 } from "zod";
var itemSchema = z13.object({
  path: z13.string()
});
var createAliasesDataSchema = z13.object({
  items: z13.array(itemSchema)
});
var deleteAliasesDataSchema = z13.object({
  items: z13.array(itemSchema)
});
var rootItemSchema = z13.object({
  datetime: z13.string().optional(),
  path: z13.string(),
  "redirect-to": z13.string()
});
var createAliasesMultipleDataSchema = z13.object({
  items: z13.array(rootItemSchema)
});

// src/restapi/aliases/add.ts
var createAliasesArgsSchema = z14.object({
  path: z14.string(),
  data: createAliasesDataSchema,
  config: PloneClientConfigSchema
});
var createAliases = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = createAliasesArgsSchema.parse({
    path,
    data,
    config
  });
  const addAliasesPath = `${validatedArgs.path}/@aliases`;
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", addAliasesPath, options);
};
var createAliasesMutation = ({
  config
}) => ({
  mutationKey: ["post", "aliases"],
  mutationFn: ({ path, data }) => createAliases({ path, data, config })
});

// src/restapi/aliases/delete.ts
import { z as z15 } from "zod";
var deleteAliasesArgsSchema = z15.object({
  path: z15.string(),
  data: deleteAliasesDataSchema,
  config: PloneClientConfigSchema
});
var deleteAliases = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = deleteAliasesArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const aliasesPath = `${validatedArgs.path}/@aliases`;
  return apiRequest("delete", aliasesPath, options);
};
var deleteAliasesMutation = ({
  config
}) => ({
  mutationKey: ["delete", "aliases"],
  mutationFn: ({ path, data }) => deleteAliases({ path, data, config })
});

// src/restapi/addons/get_list.ts
var getAddons = async ({ config }) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@addons", options);
};
var getAddonsQuery = ({ config }) => ({
  queryKey: ["get", "addons"],
  queryFn: () => getAddons({ config })
});

// src/restapi/addons/get.ts
import { z as z16 } from "zod";
var getAddonSchema = z16.object({
  addonId: z16.string()
});
var getAddon = async ({
  addonId,
  config
}) => {
  const validatedArgs = getAddonSchema.parse({
    addonId
  });
  const options = {
    config,
    params: {}
  };
  const addonName = `@addons/${validatedArgs.addonId}`;
  return apiRequest("get", addonName, options);
};
var getAddonQuery = ({ addonId, config }) => ({
  queryKey: [addonId, "get", "addons"],
  queryFn: () => getAddon({ addonId, config })
});

// src/restapi/addons/install.ts
import { z as z17 } from "zod";
var installAddonSchema = z17.object({
  addonId: z17.string()
});
var installAddon = async ({
  addonId,
  config
}) => {
  const validatedArgs = installAddonSchema.parse({
    addonId
  });
  const options = {
    config,
    params: {}
  };
  const addonName = `@addons/${validatedArgs.addonId}/install`;
  return apiRequest("post", addonName, options);
};
var installAddonMutation = ({
  config
}) => ({
  mutationKey: ["post", "addons"],
  mutationFn: ({ addonId }) => installAddon({ addonId, config })
});

// src/restapi/addons/install_profile.ts
import { z as z18 } from "zod";
var installAddonProfileSchema = z18.object({
  addonId: z18.string(),
  profile: z18.string()
});
var installAddonProfile = async ({
  addonId,
  profile,
  config
}) => {
  const validatedArgs = installAddonProfileSchema.parse({
    addonId,
    profile
  });
  const options = {
    config,
    params: {}
  };
  const addonName = `@addons/${validatedArgs.addonId}/${profile}`;
  return apiRequest("post", addonName, options);
};
var installAddonProfileMutation = ({
  config
}) => ({
  mutationKey: ["post", "addons"],
  mutationFn: ({ addonId, profile }) => installAddonProfile({ addonId, profile, config })
});

// src/restapi/addons/unistall.ts
import { z as z19 } from "zod";
var uninstallAddonSchema = z19.object({
  addonId: z19.string()
});
var uninstallAddon = async ({
  addonId,
  config
}) => {
  const validatedArgs = uninstallAddonSchema.parse({
    addonId
  });
  const options = {
    config,
    params: {}
  };
  const addonName = `@addons/${validatedArgs.addonId}/uninstall`;
  return apiRequest("post", addonName, options);
};
var uninstallAddonMutation = ({
  config
}) => ({
  mutationKey: ["post", "addons"],
  mutationFn: ({ addonId }) => uninstallAddon({ addonId, config })
});

// src/restapi/addons/upgrade.ts
import { z as z20 } from "zod";
var upgradeAddonSchema = z20.object({
  addonId: z20.string()
});
var upgradeAddon = async ({
  addonId,
  config
}) => {
  const validatedArgs = upgradeAddonSchema.parse({
    addonId
  });
  const options = {
    config,
    params: {}
  };
  const addonName = `@addons/${validatedArgs.addonId}/upgrade`;
  return apiRequest("post", addonName, options);
};
var upgradeAddonMutation = ({
  config
}) => ({
  mutationKey: ["post", "addons"],
  mutationFn: ({ addonId }) => upgradeAddon({ addonId, config })
});

// src/restapi/database/get.ts
var getDatabase = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@database", options);
};
var getDatabaseQuery = ({ config }) => ({
  queryKey: ["get", "database"],
  queryFn: () => getDatabase({ config })
});

// src/restapi/groups/get.ts
import { z as z21 } from "zod";
var getGroupSchema = z21.object({
  groupId: z21.string()
});
var getGroup = async ({
  groupId,
  config
}) => {
  const validatedArgs = getGroupSchema.parse({
    groupId
  });
  const options = {
    config,
    params: {}
  };
  const groupName = `@groups/${validatedArgs.groupId}`;
  return apiRequest("get", groupName, options);
};
var getGroupQuery = ({ groupId, config }) => ({
  queryKey: [groupId, "get", "groups"],
  queryFn: () => getGroup({ groupId, config })
});

// src/restapi/groups/add.ts
import { z as z23 } from "zod";

// src/validation/groups.ts
import { z as z22 } from "zod";
var createGroupDataSchema = z22.object({
  description: z22.string().optional(),
  email: z22.string().optional(),
  groupname: z22.string(),
  groups: z22.array(z22.string()).optional(),
  roles: z22.array(z22.string()).optional(),
  title: z22.string().optional(),
  users: z22.array(z22.string()).optional()
});
var updateGroupDataSchema = z22.object({
  description: z22.string().optional(),
  email: z22.string().optional(),
  title: z22.string().optional()
});

// src/restapi/groups/add.ts
var createGroupArgsSchema = z23.object({
  data: createGroupDataSchema,
  config: PloneClientConfigSchema
});
var createGroup = async ({
  data,
  config
}) => {
  const validatedArgs = createGroupArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", "/@groups", options);
};
var createGroupMutation = ({
  config
}) => ({
  mutationKey: ["post", "groups"],
  mutationFn: ({ data }) => createGroup({ data, config })
});

// src/restapi/groups/get_list.ts
var getGroups = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@groups", options);
};
var getGroupsQuery = ({ config }) => ({
  queryKey: ["get", "groups"],
  queryFn: () => getGroups({ config })
});

// src/restapi/groups/update.ts
import { z as z24 } from "zod";
var updateGroupArgsSchema = z24.object({
  groupId: z24.string(),
  data: updateGroupDataSchema,
  config: PloneClientConfigSchema
});
var updateGroup = async ({
  groupId,
  data,
  config
}) => {
  const validatedArgs = updateGroupArgsSchema.parse({
    groupId,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const groupName = `/@groups/${validatedArgs.groupId}`;
  return apiRequest("patch", groupName, options);
};
var updateGroupMutation = ({
  config
}) => ({
  mutationKey: ["patch", "groups"],
  mutationFn: ({ groupId, data }) => updateGroup({ groupId, data, config })
});

// src/restapi/groups/delete.ts
import { z as z25 } from "zod";
var deleteGroupArgsSchema = z25.object({
  groupId: z25.string(),
  config: PloneClientConfigSchema
});
var deleteGroup = async ({
  groupId,
  config
}) => {
  const validatedArgs = deleteGroupArgsSchema.parse({
    groupId,
    config
  });
  const options = {
    config: validatedArgs.config
  };
  const groupName = `/@groups/${validatedArgs.groupId}`;
  return apiRequest("delete", groupName, options);
};
var deleteGroupMutation = ({
  config
}) => ({
  mutationKey: ["delete", "groups"],
  mutationFn: ({ groupId }) => deleteGroup({ groupId, config })
});

// src/restapi/history/get.ts
import { z as z26 } from "zod";
var getHistorySchema = z26.object({
  path: z26.string()
});
var getHistory = async ({
  path,
  config
}) => {
  const validatedArgs = getHistorySchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const historyPath = `/${validatedArgs.path}/@history`;
  return apiRequest("get", historyPath, options);
};
var getHistoryQuery = ({ path, config }) => ({
  queryKey: [path, "get", "history"],
  queryFn: () => getHistory({ path, config })
});

// src/restapi/history/get_versioned.ts
import { z as z27 } from "zod";
var getHistoryVersionedSchema = z27.object({
  path: z27.string(),
  version: z27.number()
});
var getHistoryVersioned = async ({
  path,
  version,
  config
}) => {
  const validatedArgs = getHistoryVersionedSchema.parse({
    path,
    version
  });
  const options = {
    config,
    params: {}
  };
  const historyPath = `${validatedArgs.path}/@history/${validatedArgs.version}`;
  return apiRequest("get", historyPath, options);
};
var getHistoryVersionedQuery = ({
  path,
  version,
  config
}) => ({
  queryKey: [path, "get", "history"],
  queryFn: () => getHistoryVersioned({ path, version, config })
});

// src/restapi/history/revert.ts
import { z as z29 } from "zod";

// src/validation/history.ts
import { z as z28 } from "zod";
var revertHistoryDataSchema = z28.object({
  version: z28.number()
});

// src/restapi/history/revert.ts
var revertHistoryArgsSchema = z29.object({
  path: z29.string(),
  data: revertHistoryDataSchema,
  config: PloneClientConfigSchema
});
var revertHistory = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = revertHistoryArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const historyPath = `${validatedArgs.path}/@history`;
  return apiRequest("patch", historyPath, options);
};
var revertHistoryMutation = ({
  config
}) => ({
  mutationKey: ["patch", "history"],
  mutationFn: ({ path, data }) => revertHistory({ path, data, config })
});

// src/restapi/users/get_list.ts
import { z as z30 } from "zod";
var getUsersSchema = z30.object({
  query: z30.string().optional(),
  groupsFilter: z30.array(z30.string()).optional(),
  search: z30.string().optional(),
  limit: z30.number().optional()
});
var getUsers = async ({
  query: query2,
  groupsFilter,
  search,
  limit,
  config
}) => {
  const validatedArgs = getUsersSchema.parse({
    query: query2,
    groupsFilter,
    search,
    limit
  });
  const options = {
    config,
    params: {
      ...validatedArgs.query && { query: validatedArgs.query },
      ...validatedArgs.groupsFilter && {
        "groups-filter": validatedArgs.groupsFilter
      },
      ...validatedArgs.limit && { limit: validatedArgs.limit },
      ...validatedArgs.search && { search: validatedArgs.search }
    }
  };
  return apiRequest("get", "/@users", options);
};
var getUsersQuery = ({
  query: query2,
  groupsFilter,
  search,
  limit,
  config
}) => ({
  queryKey: [query2, groupsFilter, search, limit, "get", "users"],
  queryFn: () => getUsers({ query: query2, groupsFilter, search, limit, config })
});

// src/restapi/users/get.ts
import { z as z31 } from "zod";
var getUserSchema = z31.object({
  userId: z31.string()
});
var getUser = async ({
  userId,
  config
}) => {
  const validatedArgs = getUserSchema.parse({
    userId
  });
  const options = {
    config,
    params: {}
  };
  const userName = `@users/${validatedArgs.userId}`;
  return apiRequest("get", userName, options);
};
var getUserQuery = ({ userId, config }) => ({
  queryKey: [userId, "get", "users"],
  queryFn: () => getUser({ userId, config })
});

// src/restapi/users/add.ts
import { z as z33 } from "zod";

// src/validation/users.ts
import { z as z32 } from "zod";
var createUserDataSchema = z32.object({
  description: z32.string().optional(),
  email: z32.string().email(),
  fullname: z32.string().optional(),
  home_page: z32.string().url().optional(),
  location: z32.string().optional(),
  sendPasswordReset: z32.boolean().optional(),
  username: z32.string(),
  roles: z32.array(z32.string()).optional(),
  password: z32.string().optional()
});
var portraitSchema = z32.object({
  "content-type": z32.string(),
  data: z32.string(),
  encoding: z32.string(),
  filename: z32.string(),
  scale: z32.boolean().optional()
});
var updateUserDataSchema = z32.object({
  description: z32.string().optional(),
  email: z32.string().email().optional(),
  fullname: z32.string().optional(),
  home_page: z32.string().url().optional(),
  location: z32.string().optional(),
  username: z32.string().optional(),
  portrait: portraitSchema.optional()
});
var resetPasswordWithTokenDataSchema = z32.object({
  reset_token: z32.string(),
  new_password: z32.string()
});
var updatePasswordDataSchema = z32.object({
  new_password: z32.string(),
  old_password: z32.string()
});

// src/restapi/users/add.ts
var createUserArgsSchema = z33.object({
  data: createUserDataSchema,
  config: PloneClientConfigSchema
});
var createUser = async ({
  data,
  config
}) => {
  const validatedArgs = createUserArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", "/@users", options);
};
var createUserMutation = ({
  config
}) => ({
  mutationKey: ["post", "users"],
  mutationFn: ({ data }) => createUser({ data, config })
});

// src/restapi/users/delete.ts
import { z as z34 } from "zod";
var deleteUserArgsSchema = z34.object({
  userId: z34.string(),
  config: PloneClientConfigSchema
});
var deleteUser = async ({
  userId,
  config
}) => {
  const validatedArgs = deleteUserArgsSchema.parse({
    userId,
    config
  });
  const options = {
    config: validatedArgs.config
  };
  const userName = `/@users/${validatedArgs.userId}`;
  return apiRequest("delete", userName, options);
};
var deleteUserMutation = ({
  config
}) => ({
  mutationKey: ["delete", "users"],
  mutationFn: ({ userId }) => deleteUser({ userId, config })
});

// src/restapi/users/reset_password.ts
import { z as z35 } from "zod";
var resetPasswordArgsSchema = z35.object({
  userId: z35.string(),
  config: PloneClientConfigSchema
});
var resetPassword = async ({
  userId,
  config
}) => {
  const validatedArgs = resetPasswordArgsSchema.parse({
    userId,
    config
  });
  const options = {
    config: validatedArgs.config
  };
  const userName = `@users/${validatedArgs.userId}/reset-password`;
  return apiRequest("post", userName, options);
};
var resetPasswordMutation = ({
  config
}) => ({
  mutationKey: ["post", "user"],
  mutationFn: ({ userId }) => resetPassword({ userId, config })
});

// src/restapi/users/reset_password_with_token.ts
import { z as z36 } from "zod";
var resetPasswordWithTokenArgsSchema = z36.object({
  userId: z36.string(),
  data: resetPasswordWithTokenDataSchema,
  config: PloneClientConfigSchema
});
var resetPasswordWithToken = async ({
  userId,
  data,
  config
}) => {
  const validatedArgs = resetPasswordWithTokenArgsSchema.parse({
    userId,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const userName = `@users/${validatedArgs.userId}/reset-password`;
  return apiRequest("post", userName, options);
};
var resetPasswordWithTokenMutation = ({
  config
}) => ({
  mutationKey: ["post", "user"],
  mutationFn: ({
    userId,
    data
  }) => resetPasswordWithToken({ userId, data, config })
});

// src/restapi/users/update_password.ts
import { z as z37 } from "zod";
var updatePasswordArgsSchema = z37.object({
  userId: z37.string(),
  data: updatePasswordDataSchema,
  config: PloneClientConfigSchema
});
var updatePassword = async ({
  userId,
  data,
  config
}) => {
  const validatedArgs = updatePasswordArgsSchema.parse({
    userId,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const userName = `@users/${validatedArgs.userId}/reset-password`;
  return apiRequest("post", userName, options);
};
var updatePasswordMutation = ({
  config
}) => ({
  mutationKey: ["post", "user"],
  mutationFn: ({ userId, data }) => updatePassword({ userId, data, config })
});

// src/restapi/users/update.ts
import { z as z38 } from "zod";
var updateUserArgsSchema = z38.object({
  userId: z38.string(),
  data: updateUserDataSchema,
  config: PloneClientConfigSchema
});
var updateUser = async ({
  userId,
  data,
  config
}) => {
  const validatedArgs = updateUserArgsSchema.parse({
    userId,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const userName = `/@users/${validatedArgs.userId}`;
  return apiRequest("patch", userName, options);
};
var updateUserMutation = ({
  config
}) => ({
  mutationKey: ["patch", "users"],
  mutationFn: ({ userId, data }) => updateUser({ userId, data, config })
});

// src/restapi/relations/get_list.ts
var getRelationsList = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@relations", options);
};
var getRelationsListQuery = ({ config }) => ({
  queryKey: ["get", "relations"],
  queryFn: () => getRelationsList({ config })
});

// src/restapi/relations/get.ts
import { z as z39 } from "zod";
var getRelationsSchema = z39.object({
  source: z39.string().optional(),
  relation: z39.string().optional(),
  onlyBroken: z39.boolean().optional()
}).refine((data) => {
  return data.source !== void 0 || data.relation !== void 0;
});
var getRelations = async ({
  source,
  relation,
  onlyBroken,
  config
}) => {
  const validatedArgs = getRelationsSchema.parse({
    source,
    relation,
    onlyBroken
  });
  const options = {
    config,
    params: {
      ...validatedArgs.source && { source: validatedArgs.source },
      ...validatedArgs.relation && { relation: validatedArgs.relation },
      ...validatedArgs.onlyBroken && { relation: validatedArgs.onlyBroken }
    }
  };
  return apiRequest("get", "/@relations", options);
};
var getRelationsQuery = ({
  source,
  relation,
  onlyBroken,
  config
}) => ({
  queryKey: [source, relation, onlyBroken, "get", "relations"],
  queryFn: () => getRelations({ source, relation, onlyBroken, config })
});

// src/restapi/relations/add.ts
import { z as z41 } from "zod";

// src/validation/relations.ts
import { z as z40 } from "zod";
var RelationDataSchema = z40.object({
  relation: z40.string(),
  source: z40.string(),
  target: z40.string()
});
var createRelationsDataSchema = z40.object({
  items: z40.array(RelationDataSchema)
});
var deleteRelationsDataSchema = z40.object({
  items: z40.array(RelationDataSchema).optional(),
  relation: z40.string().optional(),
  source: z40.string().optional(),
  target: z40.string().optional()
});
var fixRelationsDataSchema = z40.object({
  flush: z40.number().optional()
});

// src/restapi/relations/add.ts
var createRelationsArgsSchema = z41.object({
  data: createRelationsDataSchema,
  config: PloneClientConfigSchema
});
var createRelations = async ({
  data,
  config
}) => {
  const validatedArgs = createRelationsArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", "/@relations", options);
};
var createRelationsMutation = ({
  config
}) => ({
  mutationKey: ["post", "relations"],
  mutationFn: ({ data }) => createRelations({ data, config })
});

// src/restapi/relations/delete.ts
import { z as z42 } from "zod";
var deleteRelationsArgsSchema = z42.object({
  data: deleteRelationsDataSchema,
  config: PloneClientConfigSchema
});
var deleteRelations = async ({
  data,
  config
}) => {
  const validatedArgs = deleteRelationsArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("delete", "/@relations", options);
};
var deleteRelationsMutation = ({
  config
}) => ({
  mutationKey: ["delete", "relations"],
  mutationFn: ({ data }) => deleteRelations({ data, config })
});

// src/restapi/relations/fix.ts
import { z as z43 } from "zod";
var fixRelationsArgsSchema = z43.object({
  data: fixRelationsDataSchema.optional(),
  config: PloneClientConfigSchema
});
var fixRelations = async ({
  data,
  config
}) => {
  const validatedArgs = fixRelationsArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", "@relations/rebuild", options);
};
var fixRelationsMutation = ({
  config
}) => ({
  mutationKey: ["post", "relations"],
  mutationFn: ({ data }) => fixRelations({ data, config })
});

// src/restapi/querystring-search/get.ts
import "zod";

// src/validation/querystring-search.ts
import { z as z44 } from "zod";
var query = z44.object({
  i: z44.string(),
  o: z44.string(),
  v: z44.union([z44.string(), z44.array(z44.string())])
});
var querystringSearchDataSchema = z44.object({
  b_start: z44.string().optional(),
  b_size: z44.string().optional(),
  limit: z44.string().optional(),
  sort_on: z44.string().optional(),
  sort_order: z44.string().optional(),
  fullobjects: z44.boolean().optional(),
  query: z44.array(query)
});

// src/restapi/querystring-search/get.ts
var getQuerystringSearch = async ({
  query: query2,
  config
}) => {
  const validatedArgs = querystringSearchDataSchema.parse({
    query: query2
  });
  const queryObject = { query: validatedArgs.query };
  const querystring = JSON.stringify(queryObject);
  const encodedQuery = encodeURIComponent(querystring);
  const options = {
    config,
    params: {
      ...encodedQuery && { query: encodedQuery }
    }
  };
  return apiRequest("get", "/@querystring-search", options);
};
var getQuerystringSearchQuery = ({
  query: query2,
  config
}) => ({
  queryKey: ["get", "querystringSearch"],
  queryFn: () => getQuerystringSearch({ query: query2, config })
});

// src/restapi/querystring-search/post.ts
import { z as z46 } from "zod";
var postQuerystringSearchArgsSchema = z46.object({
  data: querystringSearchDataSchema,
  config: PloneClientConfigSchema
});
var postQuerystringSearch = async ({
  data,
  config
}) => {
  const validatedArgs = postQuerystringSearchArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", "/@querystring-search", options);
};
var postQuerystringSearchMutation = ({
  config
}) => ({
  mutationKey: ["post", "querystring-search"],
  mutationFn: ({ data }) => postQuerystringSearch({ data, config })
});

// src/restapi/rules/get.ts
var getRules = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@content-rules", options);
};
var getRulesQuery = ({ config }) => ({
  queryKey: ["get", "rules"],
  queryFn: () => getRules({ config })
});

// src/restapi/rules/add.ts
import { z as z47 } from "zod";
var createRuleArgsSchema = z47.object({
  ruleId: z47.string(),
  config: PloneClientConfigSchema
});
var createRule = async ({
  ruleId,
  config
}) => {
  const validatedArgs = createRuleArgsSchema.parse({
    ruleId,
    config
  });
  const options = {
    config: validatedArgs.config
  };
  const addRulePath = `/@content-rules/${validatedArgs.ruleId}`;
  return apiRequest("post", addRulePath, options);
};
var createRuleMutation = ({
  config
}) => ({
  mutationKey: ["post", "rules"],
  mutationFn: ({ ruleId }) => createRule({ ruleId, config })
});

// src/restapi/rules/update.ts
import { z as z49 } from "zod";

// src/validation/rules.ts
import { z as z48 } from "zod";
var updateRulesDataSchema = z48.object({
  "form.button.Bubble": z48.boolean().optional(),
  "form.button.NoBubble": z48.boolean().optional(),
  "form.button.Enable": z48.boolean().optional(),
  "form.button.Disable": z48.boolean().optional(),
  rules_ids: z48.array(z48.string()).optional(),
  operation: z48.string().optional(),
  rule_id: z48.string().optional()
});
var deleteRulesDataSchema = z48.object({
  rules_ids: z48.array(z48.string())
});

// src/restapi/rules/update.ts
var updateRulesArgsSchema = z49.object({
  data: updateRulesDataSchema,
  config: PloneClientConfigSchema
});
var updateRules = async ({
  data,
  config
}) => {
  const validatedArgs = updateRulesArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("patch", "/@content-rules", options);
};
var updateRulesMutation = ({
  config
}) => ({
  mutationKey: ["patch", "rules"],
  mutationFn: ({ data }) => updateRules({ data, config })
});

// src/restapi/rules/delete.ts
import { z as z50 } from "zod";
var deleteRulesArgsSchema = z50.object({
  data: deleteRulesDataSchema,
  config: PloneClientConfigSchema
});
var deleteRules = async ({
  data,
  config
}) => {
  const validatedArgs = deleteRulesArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const deleteRulesPath = `/@content-rules`;
  return apiRequest("delete", deleteRulesPath, options);
};
var deleteRulesMutation = ({
  config
}) => ({
  mutationKey: ["delete", "rules"],
  mutationFn: ({ data }) => deleteRules({ data, config })
});

// src/restapi/controlpanels/get_list.ts
var getControlpanels = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@controlpanels", options);
};
var getControlpanelsQuery = ({ config }) => ({
  queryKey: ["get", "controlpanels"],
  queryFn: () => getControlpanels({ config })
});

// src/restapi/controlpanels/get.ts
import { z as z51 } from "zod";
var getControlpanelSchema = z51.object({
  path: z51.string()
});
var getControlpanel = async ({
  path,
  config
}) => {
  const validatedArgs = getControlpanelSchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const getControlpanelPath = `@controlpanels/${validatedArgs.path}`;
  return apiRequest("get", getControlpanelPath, options);
};
var getControlpanelQuery = ({ path, config }) => ({
  queryKey: [path, "get", "controlpanels"],
  queryFn: () => getControlpanel({ path, config })
});

// src/restapi/controlpanels/add.ts
import { z as z52 } from "zod";
var createControlpanelArgsSchema = z52.object({
  path: z52.string(),
  data: z52.any(),
  config: PloneClientConfigSchema
});
var createControlpanel = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = createControlpanelArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const createControlpanelPath = `@controlpanels/${validatedArgs.path}`;
  return apiRequest("post", createControlpanelPath, options);
};
var createControlpanelMutation = ({
  config
}) => ({
  mutationKey: ["post", "controlpanels"],
  mutationFn: ({ path, data }) => createControlpanel({ path, data, config })
});

// src/restapi/controlpanels/update.ts
import { z as z53 } from "zod";
var updateControlpanelArgsSchema = z53.object({
  path: z53.string(),
  data: z53.any(),
  config: PloneClientConfigSchema
});
var updateControlpanel = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = updateControlpanelArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const updateControlpanelPath = `@controlpanels/${validatedArgs.path}`;
  return apiRequest("patch", updateControlpanelPath, options);
};
var updateControlpanelMutation = ({
  config
}) => ({
  mutationKey: ["patch", "controlpanels"],
  mutationFn: ({ path, data }) => updateControlpanel({ path, data, config })
});

// src/restapi/controlpanels/delete.ts
import { z as z54 } from "zod";
var deleteControlpanelArgsSchema = z54.object({
  path: z54.string(),
  data: z54.any(),
  config: PloneClientConfigSchema
});
var deleteControlpanel = async ({
  path,
  data,
  config
}) => {
  const validatedArgs = deleteControlpanelArgsSchema.parse({
    path,
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  const deleteControlpanelPath = `@controlpanels/${validatedArgs.path}`;
  return apiRequest("delete", deleteControlpanelPath, options);
};
var deleteControlpanelMutation = ({
  config
}) => ({
  mutationKey: ["delete", "controlpanels"],
  mutationFn: ({ path, data }) => deleteControlpanel({ path, data, config })
});

// src/restapi/search/get.ts
import "zod";

// src/validation/search.ts
import { z as z55 } from "zod";
var querySchema = z55.object({
  path: z55.object({
    query: z55.union([z55.string(), z55.array(z55.string())]),
    depth: z55.number().optional()
  }).optional(),
  sort_on: z55.union([z55.string(), z55.array(z55.string())]).optional(),
  SearchableText: z55.string().optional(),
  metadata_fields: z55.union([z55.string(), z55.array(z55.string())]).optional(),
  fullobjects: z55.number().optional()
}).and(z55.record(z55.any()));
var getSearchSchema = z55.object({
  query: querySchema
});

// src/utils/misc.ts
import {
  useMutation,
  useQuery
} from "@tanstack/react-query";
var queryWithConfig = (method, configGetter) => {
  return (args) => method({ ...args, config: configGetter() });
};
var mutationWithConfig = (method, configGetter) => {
  return () => method({ config: configGetter() });
};
var flattenToDottedNotation = (obj, prefix = "") => {
  const result = {};
  for (const key of Object.keys(obj)) {
    const value = obj[key];
    const newKey = prefix ? `${prefix}.${key}` : key;
    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
      Object.assign(result, flattenToDottedNotation(value, newKey));
    } else {
      result[newKey] = value;
    }
  }
  return result;
};
var queryHookFromQuery = (queryFnCreator) => {
  return (args) => useQuery(queryFnCreator(args));
};
var mutationHookFromMutation = (mutationFnCreator) => {
  return () => useMutation(mutationFnCreator());
};

// src/restapi/search/get.ts
var getSearch = async ({
  query: query2,
  config
}) => {
  const validatedArgs = getSearchSchema.parse({
    query: query2
  });
  const flattenedQuery = flattenToDottedNotation(validatedArgs.query);
  const options = {
    config,
    params: {
      ...flattenedQuery,
      "path.query": void 0
    }
  };
  return apiRequest("get", `${query2.path?.query ?? ""}/@search`, options);
};
var getSearchQuery = ({ query: query2, config }) => ({
  queryKey: [query2, "get", "search"],
  queryFn: () => getSearch({ query: query2, config })
});

// src/restapi/querysources/get.ts
import { z as z57 } from "zod";
var getQuerysourceSchema = z57.object({
  path: z57.string(),
  field: z57.string(),
  query: z57.string()
});
var getQuerysource = async ({
  path,
  field,
  query: query2,
  config
}) => {
  const validatedArgs = getQuerysourceSchema.parse({
    path,
    field,
    query: query2
  });
  const options = {
    config,
    params: {
      ...validatedArgs.query && { query: validatedArgs.query }
    }
  };
  const querysourcePath = `/${validatedArgs.path}/@querysources/${field}`;
  return apiRequest("get", querysourcePath, options);
};
var getQuerysourceQuery = ({
  path,
  field,
  query: query2,
  config
}) => ({
  queryKey: [path, field, query2, "get", "querysources"],
  queryFn: () => getQuerysource({ path, field, query: query2, config })
});

// src/restapi/sources/get.ts
import { z as z58 } from "zod";
var getSourceSchema = z58.object({
  path: z58.string(),
  field: z58.string()
});
var getSource = async ({
  path,
  field,
  config
}) => {
  const validatedArgs = getSourceSchema.parse({
    path,
    field
  });
  const options = {
    config
  };
  const sourcePath = `/${validatedArgs.path}/@sources/${field}`;
  return apiRequest("get", sourcePath, options);
};
var getSourceQuery = ({ path, field, config }) => ({
  queryKey: [path, field, "get", "sources"],
  queryFn: () => getSource({ path, field, config })
});

// src/restapi/userschema/get.ts
var getUserschema = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@userschema", options);
};
var getUserschemaQuery = ({ config }) => ({
  queryKey: ["get", "userschema"],
  queryFn: () => getUserschema({ config })
});

// src/restapi/roles/get.ts
var getRoles = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@roles", options);
};
var getRolesQuery = ({ config }) => ({
  queryKey: ["get", "roles"],
  queryFn: () => getRoles({ config })
});

// src/restapi/system/get.ts
var getSystem = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@system", options);
};
var getSystemQuery = ({ config }) => ({
  queryKey: ["get", "system"],
  queryFn: () => getSystem({ config })
});

// src/restapi/transactions/get.ts
var getTransactions = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@transactions", options);
};
var getTransactionsQuery = ({ config }) => ({
  queryKey: ["get", "transactions"],
  queryFn: () => getTransactions({ config })
});

// src/restapi/transactions/revert.ts
import { z as z60 } from "zod";

// src/validation/transactions.ts
import { z as z59 } from "zod";
var revertTransactionsDataSchema = z59.object({
  transaction_ids: z59.array(z59.string())
});

// src/restapi/transactions/revert.ts
var revertTransactionsArgsSchema = z60.object({
  data: revertTransactionsDataSchema,
  config: PloneClientConfigSchema
});
var revertTransactions = async ({
  data,
  config
}) => {
  const validatedArgs = revertTransactionsArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("patch", "/@transactions", options);
};
var revertTransactionsMutation = ({
  config
}) => ({
  mutationKey: ["patch", "transactions"],
  mutationFn: ({ data }) => revertTransactions({ data, config })
});

// src/restapi/upgrade/get.ts
var getUpgrade = async ({
  config
}) => {
  const options = {
    config,
    params: {}
  };
  return apiRequest("get", "/@upgrade", options);
};
var getUpgradeQuery = ({ config }) => ({
  queryKey: ["get", "upgrade"],
  queryFn: () => getUpgrade({ config })
});

// src/restapi/upgrade/run.ts
import { z as z62 } from "zod";

// src/validation/upgrade.ts
import { z as z61 } from "zod";
var runUpgradeDataSchema = z61.object({
  dry_run: z61.boolean()
});

// src/restapi/upgrade/run.ts
var runUpgradeArgsSchema = z62.object({
  data: runUpgradeDataSchema,
  config: PloneClientConfigSchema
});
var runUpgrade = async ({
  data,
  config
}) => {
  const validatedArgs = runUpgradeArgsSchema.parse({
    data,
    config
  });
  const options = {
    data: validatedArgs.data,
    config: validatedArgs.config
  };
  return apiRequest("post", "/@upgrade", options);
};
var runUpgradeMutation = ({
  config
}) => ({
  mutationKey: ["post", "upgrade"],
  mutationFn: ({ data }) => runUpgrade({ data, config })
});

// src/restapi/linkintegrity/get.ts
import { z as z63 } from "zod";
var getLinkintegriyArgsSchema = z63.object({
  uids: z63.string(),
  config: PloneClientConfigSchema
});
var getLinkintegrity = async ({
  uids,
  config
}) => {
  const validatedArgs = getLinkintegriyArgsSchema.parse({
    uids,
    config
  });
  const options = {
    config,
    params: {
      ...validatedArgs && { uids: validatedArgs.uids }
    }
  };
  return apiRequest("get", "/@linkintegrity", options);
};
var getLinkintegrityQuery = ({
  uids,
  config
}) => ({
  queryKey: ["get", "linkintegrity"],
  queryFn: () => getLinkintegrity({ uids, config })
});

// src/restapi/principals/get.ts
import { z as z64 } from "zod";
var getPrincipalsSchema = z64.object({
  search: z64.string()
});
var getPrincipals = async ({
  search,
  config
}) => {
  const validatedArgs = getPrincipalsSchema.parse({
    search
  });
  const options = {
    config,
    params: {}
  };
  const principalsPath = `/@principals?search=${validatedArgs.search}`;
  return apiRequest("get", principalsPath, options);
};
var getPrincipalsQuery = ({ search, config }) => ({
  queryKey: [search, "get", "principals"],
  queryFn: () => getPrincipals({ search, config })
});

// src/restapi/workingcopy/get.ts
import { z as z65 } from "zod";
var getWorkingcopySchema = z65.object({
  path: z65.string()
});
var getWorkingcopy = async ({
  path,
  config
}) => {
  const validatedArgs = getWorkingcopySchema.parse({
    path
  });
  const options = {
    config,
    params: {}
  };
  const workingcopyPath = `/${validatedArgs.path}/@workingcopy`;
  return apiRequest("get", workingcopyPath, options);
};
var getWorkingcopyQuery = ({ path, config }) => ({
  queryKey: [path, "get", "workingcopy"],
  queryFn: () => getWorkin