@plone/client/dist/index.cjs

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

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  default: () => src_default
});
module.exports = __toCommonJS(src_exports);

// src/API.ts
var import_axios = __toESM(require("axios"), 1);
var import_query_string = __toESM(require("query-string"), 1);
var import_debug = __toESM(require("debug"), 1);
var debug = (0, import_debug.default)("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 import_query_string.default.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 = import_axios.default.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
var import_zod2 = require("zod");

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

// src/restapi/login/post.ts
var loginArgsSchema = import_zod2.z.object({
  username: import_zod2.z.string(),
  password: import_zod2.z.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
var import_zod3 = require("zod");
var getContentArgsSchema = import_zod3.z.object({
  path: import_zod3.z.string(),
  version: import_zod3.z.string().optional(),
  page: import_zod3.z.number().optional(),
  fullObjects: import_zod3.z.boolean().optional(),
  expand: import_zod3.z.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
var import_zod5 = require("zod");

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

// src/restapi/content/add.ts
var createContentArgsSchema = import_zod5.z.object({
  path: import_zod5.z.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
var import_zod6 = require("zod");
var updateContentArgsSchema = import_zod6.z.object({
  path: import_zod6.z.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
var import_zod7 = require("zod");
var deleteContentArgsSchema = import_zod7.z.object({
  path: import_zod7.z.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
var import_zod8 = require("zod");
var getBreadcrumbsSchema = import_zod8.z.object({
  path: import_zod8.z.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
var import_zod9 = require("zod");
var getNavigationSchema = import_zod9.z.object({
  path: import_zod9.z.string(),
  depth: import_zod9.z.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
var import_zod10 = require("zod");
var getContextNavigationSchema = import_zod10.z.object({
  path: import_zod10.z.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
var import_zod11 = require("zod");
var getActionsSchema = import_zod11.z.object({
  path: import_zod11.z.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
var import_zod12 = require("zod");
var getAliasesSchema = import_zod12.z.object({
  path: import_zod12.z.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
var import_zod14 = require("zod");

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

// src/restapi/aliases/add.ts
var createAliasesArgsSchema = import_zod14.z.object({
  path: import_zod14.z.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
var import_zod15 = require("zod");
var deleteAliasesArgsSchema = import_zod15.z.object({
  path: import_zod15.z.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
var import_zod16 = require("zod");
var getAddonSchema = import_zod16.z.object({
  addonId: import_zod16.z.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
var import_zod17 = require("zod");
var installAddonSchema = import_zod17.z.object({
  addonId: import_zod17.z.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
var import_zod18 = require("zod");
var installAddonProfileSchema = import_zod18.z.object({
  addonId: import_zod18.z.string(),
  profile: import_zod18.z.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
var import_zod19 = require("zod");
var uninstallAddonSchema = import_zod19.z.object({
  addonId: import_zod19.z.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
var import_zod20 = require("zod");
var upgradeAddonSchema = import_zod20.z.object({
  addonId: import_zod20.z.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
var import_zod21 = require("zod");
var getGroupSchema = import_zod21.z.object({
  groupId: import_zod21.z.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
var import_zod23 = require("zod");

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

// src/restapi/groups/add.ts
var createGroupArgsSchema = import_zod23.z.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
var import_zod24 = require("zod");
var updateGroupArgsSchema = import_zod24.z.object({
  groupId: import_zod24.z.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
var import_zod25 = require("zod");
var deleteGroupArgsSchema = import_zod25.z.object({
  groupId: import_zod25.z.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
var import_zod26 = require("zod");
var getHistorySchema = import_zod26.z.object({
  path: import_zod26.z.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
var import_zod27 = require("zod");
var getHistoryVersionedSchema = import_zod27.z.object({
  path: import_zod27.z.string(),
  version: import_zod27.z.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
var import_zod29 = require("zod");

// src/validation/history.ts
var import_zod28 = require("zod");
var revertHistoryDataSchema = import_zod28.z.object({
  version: import_zod28.z.number()
});

// src/restapi/history/revert.ts
var revertHistoryArgsSchema = import_zod29.z.object({
  path: import_zod29.z.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
var import_zod30 = require("zod");
var getUsersSchema = import_zod30.z.object({
  query: import_zod30.z.string().optional(),
  groupsFilter: import_zod30.z.array(import_zod30.z.string()).optional(),
  search: import_zod30.z.string().optional(),
  limit: import_zod30.z.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
var import_zod31 = require("zod");
var getUserSchema = import_zod31.z.object({
  userId: import_zod31.z.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
var import_zod33 = require("zod");

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

// src/restapi/users/add.ts
var createUserArgsSchema = import_zod33.z.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
var import_zod34 = require("zod");
var deleteUserArgsSchema = import_zod34.z.object({
  userId: import_zod34.z.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
var import_zod35 = require("zod");
var resetPasswordArgsSchema = import_zod35.z.object({
  userId: import_zod35.z.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
var import_zod36 = require("zod");
var resetPasswordWithTokenArgsSchema = import_zod36.z.object({
  userId: import_zod36.z.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
var import_zod37 = require("zod");
var updatePasswordArgsSchema = import_zod37.z.object({
  userId: import_zod37.z.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
var import_zod38 = require("zod");
var updateUserArgsSchema = import_zod38.z.object({
  userId: import_zod38.z.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
var import_zod39 = require("zod");
var getRelationsSchema = import_zod39.z.object({
  source: import_zod39.z.string().optional(),
  relation: import_zod39.z.string().optional(),
  onlyBroken: import_zod39.z.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
var import_zod41 = require("zod");

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

// src/restapi/relations/add.ts
var createRelationsArgsSchema = import_zod41.z.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
var import_zod42 = require("zod");
var deleteRelationsArgsSchema = import_zod42.z.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
var import_zod43 = require("zod");
var fixRelationsArgsSchema = import_zod43.z.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
var import_zod45 = require("zod");

// src/validation/querystring-search.ts
var import_zod44 = require("zod");
var query = import_zod44.z.object({
  i: import_zod44.z.string(),
  o: import_zod44.z.string(),
  v: import_zod44.z.union([import_zod44.z.string(), import_zod44.z.array(import_zod44.z.string())])
});
var querystringSearchDataSchema = import_zod44.z.object({
  b_start: import_zod44.z.string().optional(),
  b_size: import_zod44.z.string().optional(),
  limit: import_zod44.z.string().optional(),
  sort_on: import_zod44.z.string().optional(),
  sort_order: import_zod44.z.string().optional(),
  fullobjects: import_zod44.z.boolean().optional(),
  query: import_zod44.z.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
var import_zod46 = require("zod");
var postQuerystringSearchArgsSchema = import_zod46.z.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
var import_zod47 = require("zod");
var createRuleArgsSchema = import_zod47.z.object({
  ruleId: import_zod47.z.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
var import_zod49 = require("zod");

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

// src/restapi/rules/update.ts
var updateRulesArgsSchema = import_zod49.z.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
var import_zod50 = require("zod");
var deleteRulesArgsSchema = import_zod50.z.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
var import_zod51 = require("zod");
var getControlpanelSchema = import_zod51.z.object({
  path: import_zod51.z.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
var import_zod52 = require("zod");
var createControlpanelArgsSchema = import_zod52.z.object({
  path: import_zod52.z.string(),
  data: import_zod52.z.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
var import_zod53 = require("zod");
var updateControlpanelArgsSchema = import_zod53.z.object({
  path: import_zod53.z.string(),
  data: import_zod53.z.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
var import_zod54 = require("zod");
var deleteControlpanelArgsSchema = import_zod54.z.object({
  path: import_zod54.z.string(),
  data: import_zod54.z.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
var import_zod56 = require("zod");

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

// src/utils/misc.ts
var import_react_query = require("@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) => (0, import_react_query.useQuery)(queryFnCreator(args));
};
var mutationHookFromMutation = (mutationFnCreator) => {
  return () => (0, import_react_query.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
var import_zod57 = require("zod");
var getQuerysourceSchema = import_zod57.z.object({
  path: import_zod57.z.string(),
  field: import_zod57.z.string(),
  query: import_zod57.z.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, fi