@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.4

package/app/index.js

@@ -0,0 +1,810 @@
+import { createContext, useContext, useRef, useMemo, useCallback, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import styled from 'styled-components';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/app/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  ApplicationStateContext: () => ApplicationStateContext,
+  ApplicationStateProvider: () => ApplicationStateProvider,
+  Route: () => Route,
+  RouteContext: () => RouteContext,
+  RouteContextConsumer: () => RouteContextConsumer,
+  RouteContextProvider: () => RouteContextProvider,
+  TypeInfoORMClient: () => TypeInfoORMClient,
+  getApplicationStateIdentifier: () => getApplicationStateIdentifier,
+  getApplicationStateModified: () => getApplicationStateModified,
+  getApplicationStateValue: () => getApplicationStateValue,
+  getApplicationStateValueStructure: () => getApplicationStateValueStructure,
+  getChangedDependencyIndexes: () => getChangedDependencyIndexes,
+  getEasyLayout: () => getEasyLayout,
+  getEasyLayoutTemplateDetails: () => getEasyLayoutTemplateDetails,
+  getFullUrl: () => getFullUrl,
+  getPascalCaseAreaName: () => getPascalCaseAreaName,
+  handleRequest: () => handleRequest,
+  requestHandlerFactory: () => requestHandlerFactory,
+  sendServiceRequest: () => sendServiceRequest,
+  setApplicationStateModified: () => setApplicationStateModified,
+  setApplicationStateValue: () => setApplicationStateValue,
+  useApplicationStateLoader: () => useApplicationStateLoader,
+  useApplicationStateValue: () => useApplicationStateValue,
+  useApplicationStateValueStructure: () => useApplicationStateValueStructure,
+  useController: () => useController,
+  useDebugDependencies: () => useDebugDependencies,
+  useRouteContext: () => useRouteContext,
+  useTypeInfoORMAPI: () => useTypeInfoORMAPI
+});
+var getApplicationStateIdentifier = (subStateIdMap) => subStateIdMap ? subStateIdMap : {};
+var getApplicationStateModified = (identifier, modificationState) => !!modificationState.get(identifier);
+var getApplicationStateValue = (identifier, applicationState) => applicationState.get(identifier);
+var setApplicationStateModified = (identifier, value, modificationState) => new Map(modificationState).set(identifier, value);
+var setApplicationStateValue = (identifier, value, applicationState) => new Map(applicationState).set(identifier, value);
+var getApplicationStateValueStructure = (idStructure, applicationState) => Object.keys(idStructure).reduce(
+  (acc, k) => ({
+    ...acc,
+    [k]: getApplicationStateValue(idStructure[k], applicationState)
+  }),
+  {}
+);
+var ApplicationStateContext = createContext({
+  modified: /* @__PURE__ */ new Map(),
+  value: /* @__PURE__ */ new Map(),
+  onChange: () => {
+  },
+  setModified: () => {
+  }
+});
+var { Provider } = ApplicationStateContext;
+var useApplicationStateValue = (identifier) => {
+  const {
+    modified: modificationState,
+    value: applicationState,
+    onChange: setApplicationState,
+    setModified: setModificationState
+  } = useContext(ApplicationStateContext);
+  const appStateRef = useRef(applicationState);
+  appStateRef.current = applicationState;
+  const modified = useMemo(
+    () => getApplicationStateModified(identifier, modificationState),
+    [identifier, modificationState]
+  );
+  const value = useMemo(
+    () => getApplicationStateValue(identifier, applicationState),
+    [identifier, applicationState]
+  );
+  const setModified = useCallback(
+    (isModified) => {
+      setModificationState(
+        setApplicationStateModified(identifier, isModified, modificationState)
+      );
+    },
+    [identifier, setModificationState]
+  );
+  const onChange = useCallback(
+    (newValue) => {
+      setApplicationState(
+        setApplicationStateValue(identifier, newValue, appStateRef.current)
+      );
+      setModified(true);
+    },
+    [identifier, setApplicationState]
+  );
+  const controller = useMemo(
+    () => ({
+      modified,
+      value,
+      onChange,
+      setModified
+    }),
+    [modified, onChange, setModified, value]
+  );
+  return controller;
+};
+var useApplicationStateValueStructure = (idStructure) => {
+  const { value: applicationState, onChange: setApplicationState } = useContext(
+    ApplicationStateContext
+  );
+  const valueStructure = useMemo(
+    () => getApplicationStateValueStructure(idStructure, applicationState),
+    [applicationState, idStructure]
+  );
+  const onChangeStructure = useMemo(
+    () => Object.keys(idStructure).reduce(
+      (acc, k) => ({
+        ...acc,
+        [k]: (newValue) => {
+          setApplicationState(
+            setApplicationStateValue(
+              idStructure[k],
+              newValue,
+              applicationState
+            )
+          );
+        }
+      }),
+      {}
+    ),
+    [applicationState, idStructure, setApplicationState]
+  );
+  const controller = useMemo(
+    () => ({
+      valueStructure,
+      onChangeStructure
+    }),
+    [onChangeStructure, valueStructure]
+  );
+  return controller;
+};
+var ApplicationStateProvider = ({
+  children
+}) => {
+  const [modified, setModified] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [value, setValue] = useState(/* @__PURE__ */ new Map());
+  const controller = useMemo(
+    () => ({
+      modified,
+      value,
+      onChange: setValue,
+      setModified
+    }),
+    [modified, value]
+  );
+  return /* @__PURE__ */ jsx(Provider, { value: controller, children });
+};
+
+// src/common/Routing.ts
+var PATH_DELIMITER = "/";
+var getPotentialJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return value;
+  }
+};
+var getPathArray = (path, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriDecodeParts = true) => path.split(delimiter).filter(filterEmptyInput ? (p) => p !== "" : () => true).map(uriDecodeParts ? decodeURIComponent : (x) => x).map(useJson ? getPotentialJSONValue : (p) => p).filter(filterEmptyOutput ? (p) => p ?? false : () => true);
+var getPathString = (parts = [], delimiter = PATH_DELIMITER, filterEmptyInput = false, useJson = true, uriEncodeParts = false) => parts.filter(filterEmptyInput ? (p) => p ?? false : () => true).map(useJson ? (p) => JSON.stringify(p) : (x) => x).map(uriEncodeParts ? encodeURIComponent : (x) => x).join(delimiter);
+var mergeStringPaths = (path1, path2, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriEncodeParts = false) => getPathString(
+  [
+    ...getPathArray(
+      path1,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    ),
+    ...getPathArray(
+      path2,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    )
+  ],
+  delimiter,
+  filterEmptyInput,
+  useJson,
+  uriEncodeParts
+);
+var resolvePath = (currentPath, newPath) => {
+  const newSegments = getPathArray(newPath, PATH_DELIMITER, true);
+  let currentSegments = getPathArray(currentPath, PATH_DELIMITER, true);
+  if (newPath.startsWith("/")) {
+    currentSegments = [];
+  }
+  newSegments.forEach((segment) => {
+    if (segment === "..") {
+      if (currentSegments.length > 0) {
+        currentSegments.pop();
+      }
+    } else if (segment !== ".") {
+      currentSegments.push(segment);
+    }
+  });
+  return "/" + currentSegments.join("/");
+};
+var getParamsAndTestPath = (path, testPath, exact = false) => {
+  const pathList = getPathArray(path);
+  const testPathList = getPathArray(testPath);
+  if (exact && pathList.length !== testPathList.length) {
+    return false;
+  } else {
+    let params = {};
+    if (pathList.length >= testPathList.length) {
+      for (let i = 0; i < testPathList.length; i++) {
+        const testPathPart = testPathList[i];
+        const pathPart = pathList[i];
+        if (testPathPart.startsWith(":")) {
+          const paramName = testPathPart.slice(1);
+          params[paramName] = pathPart;
+        } else if (pathPart !== testPathPart) {
+          return false;
+        }
+      }
+    } else {
+      return false;
+    }
+    return params;
+  }
+};
+
+// src/app/utils/Service.ts
+var getFullUrl = (protocol, domain, basePath = "", path = "", port) => {
+  const portString = !!port ? `:${port}` : "";
+  const fullPath = mergeStringPaths(
+    basePath,
+    path,
+    PATH_DELIMITER,
+    false,
+    false,
+    false
+  );
+  return `${protocol}://${domain}${portString}${fullPath}`;
+};
+var sendServiceRequest = async (config, path = "", args = []) => {
+  const { protocol, domain, port, basePath = "", authorization = "" } = config;
+  const fullUrl = getFullUrl(protocol, domain, basePath, path, port);
+  const requestHeaders = !!authorization ? {
+    Authorization: `Bearer ${authorization}`
+  } : void 0;
+  const response = await fetch(fullUrl, {
+    headers: requestHeaders,
+    credentials: "same-origin",
+    method: "POST",
+    body: JSON.stringify(args)
+  });
+  const { ok: responseIsOk } = response;
+  const data = await response.json();
+  if (responseIsOk) {
+    return data;
+  } else {
+    throw data;
+  }
+};
+var useApplicationStateLoader = (config) => {
+  const {
+    identifier,
+    remoteProcedureCall,
+    resetOnError = false,
+    onLoadComplete,
+    manual = false
+  } = config;
+  const { args = [] } = remoteProcedureCall;
+  const argsRef = useRef(args);
+  argsRef.current = args;
+  const [cacheValidity, setCacheValidity] = useState({});
+  const [loading, setLoading] = useState(false);
+  const [latestError, setLatestError] = useState();
+  const { onChange, setModified } = useApplicationStateValue(identifier);
+  const invalidate = useCallback(() => {
+    setCacheValidity({});
+  }, []);
+  const makeRemoteProcedureCall = useCallback(
+    async (...directArgs) => {
+      let success;
+      setLoading(true);
+      setLatestError(void 0);
+      try {
+        const { serviceConfig, path } = remoteProcedureCall;
+        const result = await sendServiceRequest(
+          serviceConfig,
+          path,
+          directArgs
+        );
+        success = true;
+        onChange(result);
+        setModified(false);
+      } catch (error) {
+        success = false;
+        setLatestError(error);
+        if (resetOnError) {
+          onChange(void 0);
+          setModified(false);
+        }
+      }
+      setLoading(false);
+      onLoadComplete?.(success);
+    },
+    [remoteProcedureCall, onChange, setModified, resetOnError, onLoadComplete]
+  );
+  const appStateLoader = useMemo(
+    () => ({
+      loading,
+      latestError,
+      invalidate,
+      makeRemoteProcedureCall
+    }),
+    [loading, latestError, invalidate, makeRemoteProcedureCall]
+  );
+  useEffect(() => {
+    if (!manual && argsRef.current) {
+      makeRemoteProcedureCall(...argsRef.current);
+    }
+  }, [cacheValidity, manual, makeRemoteProcedureCall]);
+  return appStateLoader;
+};
+var getKeyValueWithoutError = (obj, key) => {
+  try {
+    return obj[key];
+  } catch (e) {
+    return void 0;
+  }
+};
+var useController = (parentValue, key, onParentValueChange, isArrayIndex = false) => {
+  const [value, setValue] = useState(getKeyValueWithoutError(parentValue, key));
+  const onChange = useCallback(
+    (value2) => {
+      try {
+        setValue(value2);
+        if (isArrayIndex) {
+          const newArray = [...parentValue];
+          newArray[key] = value2;
+          onParentValueChange(newArray);
+        } else {
+          onParentValueChange({
+            ...parentValue,
+            [key]: value2
+          });
+        }
+      } catch (e) {
+      }
+    },
+    [parentValue, key, onParentValueChange, isArrayIndex]
+  );
+  useEffect(() => {
+    try {
+      setValue(getKeyValueWithoutError(parentValue, key));
+    } catch (e) {
+      setValue(void 0);
+    }
+  }, [parentValue, key]);
+  return [value, onChange];
+};
+var getChangedDependencyIndexes = (prevDeps, nextDeps) => nextDeps.map((dep, i) => dep !== prevDeps[i] ? i : null).filter((dep) => dep !== null);
+var useDebugDependencies = (dependencies) => {
+  const firstRender = useRef(true);
+  const prevDeps = useRef(dependencies);
+  useEffect(() => {
+    if (firstRender.current) {
+      firstRender.current = false;
+      return;
+    }
+    const changedDeps = getChangedDependencyIndexes(
+      prevDeps.current,
+      dependencies
+    );
+    if (changedDeps.length > 0) {
+      console.log("Changed dependencies:", changedDeps);
+    }
+    prevDeps.current = dependencies;
+  }, dependencies);
+};
+var getPascalCaseAreaName = (area) => {
+  return area.split("-").map((a) => a[0].toUpperCase() + a.slice(1)).join("");
+};
+var convertLayoutToCSS = (layout = "") => {
+  const lines = layout.split("\n");
+  let areaRows = [];
+  let rows = [];
+  let css = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.indexOf("\\") === 0) {
+      css += `
+grid-template-columns: ${line.split("\\").join("").trim()};`;
+    } else {
+      const parts = line.split(",").map((p) => p && p.trim());
+      if (parts[0]) {
+        areaRows = [...areaRows, parts[0]];
+        if (parts[1]) {
+          rows = [...rows, parts[1]];
+        }
+      }
+    }
+  }
+  css += `
+grid-template-areas:
+${areaRows.filter((a) => !!(a && a.trim())).map((a) => `  "${a}"`).join("\n")};`;
+  if (rows.length) {
+    css += `
+grid-template-rows: ${rows.filter((r) => !!(r && r.trim())).join(" ")};`;
+  }
+  const areasList = Object.keys(
+    areaRows.reduce(
+      (acc, a) => [
+        ...acc,
+        ...a.split(" ").map((a2) => a2 && a2.trim()).filter((a2) => !!a2)
+      ],
+      []
+    ).reduce((acc, a) => ({ ...acc, [a]: true }), {})
+  );
+  return {
+    areasList,
+    css
+  };
+};
+var getEasyLayoutTemplateDetails = (layout = "") => convertLayoutToCSS(layout);
+var getEasyLayout = (extendFrom, areasExtendFrom) => {
+  return (layoutTemplate, ...expressions) => {
+    const mergedTemplate = layoutTemplate.reduce((acc, l, ind) => {
+      const expr = expressions[ind - 1];
+      const exprStr = typeof expr === "undefined" ? "" : expr;
+      return `${acc}${l}${exprStr}`;
+    }, "");
+    const { areasList, css } = convertLayoutToCSS(mergedTemplate);
+    const baseLayoutComp = extendFrom ? styled(extendFrom) : styled.div;
+    const layout = baseLayoutComp`
+    display: grid;
+    ${css}
+  `;
+    const areas = areasList.reduce((acc, area) => {
+      const pascalCaseAreaName = getPascalCaseAreaName(area);
+      const baseCompFunc = areasExtendFrom ? styled(areasExtendFrom) : styled.div;
+      const component = baseCompFunc`
+      grid-area: ${area};
+    `;
+      return {
+        ...acc,
+        [pascalCaseAreaName]: component
+      };
+    }, {});
+    return {
+      layout,
+      areas
+    };
+  };
+};
+(function(history2) {
+  const pushState = history2.pushState;
+  history2.pushState = function(state, ...remainingArguments) {
+    if (typeof history2.onpushstate == "function") {
+      history2.onpushstate({ state });
+    }
+    const result = pushState.apply(history2, [state, ...remainingArguments]);
+    window.dispatchEvent(new CustomEvent("statechanged", { detail: state }));
+    return result;
+  };
+})(window.history);
+var CURRENT_PATH = window.location.pathname;
+var RouteContext = createContext({
+  currentWindowPath: CURRENT_PATH,
+  parentPath: "",
+  params: {},
+  isTopLevel: true
+});
+var {
+  /**
+   * @ignore
+   * */
+  Provider: RouteContextProvider,
+  /**
+   * @ignore
+   * */
+  Consumer: RouteContextConsumer
+} = RouteContext;
+var useRouteContext = () => useContext(RouteContext);
+var Route = ({
+  /**
+   * Use `:` as the first character to denote a parameter in the path.
+   * */
+  path = "",
+  onParamsChange,
+  exact = false,
+  children
+}) => {
+  const [currentPath = "", setCurrentPath] = useState(CURRENT_PATH);
+  const {
+    currentWindowPath = "",
+    parentPath = "",
+    params: parentParams = {},
+    isTopLevel
+  } = useRouteContext();
+  const targetCurrentPath = useMemo(
+    () => isTopLevel ? currentPath : currentWindowPath,
+    [isTopLevel, currentPath, currentWindowPath]
+  );
+  const fullPath = useMemo(
+    () => mergeStringPaths(parentPath, path),
+    [parentPath, path]
+  );
+  const newParams = useMemo(
+    () => getParamsAndTestPath(targetCurrentPath, fullPath, exact),
+    [targetCurrentPath, fullPath, exact]
+  );
+  const params = useMemo(
+    () => ({
+      ...parentParams,
+      ...newParams ? newParams : {}
+    }),
+    [parentParams, newParams]
+  );
+  const newRouteContext = useMemo(
+    () => ({
+      currentWindowPath: targetCurrentPath,
+      parentPath: fullPath,
+      params,
+      isTopLevel: false
+    }),
+    [targetCurrentPath, fullPath, params]
+  );
+  useEffect(() => {
+    if (onParamsChange) {
+      onParamsChange(params);
+    }
+  }, [params, onParamsChange]);
+  useEffect(() => {
+    if (isTopLevel) {
+      const handleAnchorClick = (event) => {
+        let target = event.target;
+        while (target && target.nodeName !== "A") {
+          target = target.parentNode;
+        }
+        if (target && target.nodeName === "A") {
+          const aTarget = target;
+          const href = aTarget.getAttribute("href");
+          const title = aTarget.getAttribute("title") ?? "";
+          try {
+            new URL(href ? href : "");
+          } catch (error) {
+            const newPath = resolvePath(
+              window.location.pathname,
+              href ? href : ""
+            );
+            event.preventDefault();
+            history.pushState({}, title, newPath);
+            setCurrentPath(newPath);
+          }
+        }
+      };
+      const handlePopOrReplaceState = () => {
+        setCurrentPath(window.location.pathname);
+      };
+      window.document.addEventListener("click", handleAnchorClick);
+      window.addEventListener("popstate", handlePopOrReplaceState);
+      window.addEventListener("statechanged", handlePopOrReplaceState);
+      return () => {
+        window.document.removeEventListener("click", handleAnchorClick);
+        window.removeEventListener("popstate", handlePopOrReplaceState);
+        window.removeEventListener("statechanged", handlePopOrReplaceState);
+      };
+    }
+  }, [isTopLevel]);
+  return newParams ? /* @__PURE__ */ jsx(RouteContextProvider, { value: newRouteContext, children }) : null;
+};
+
+// src/common/IdGeneration/getSimpleId.ts
+var LAST_HAST_ID = 0;
+var getBase64EncodedString = (input) => Buffer.from(input).toString("base64");
+var getSimpleId = () => {
+  const hashId = LAST_HAST_ID++;
+  const base64Datetime = getBase64EncodedString(
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const rand1 = Math.random().toString(36).substring(2, 15);
+  const rand2 = Math.random().toString(36).substring(2, 15);
+  return `${hashId}-${base64Datetime}-${rand1}-${rand2}`;
+};
+
+// src/app/utils/TypeInfoORMAPIUtils.ts
+var handleRequest = async (requestId, args, typeInfoORMAPI, methodName, onRequestStateChange) => {
+  onRequestStateChange(methodName, requestId, { loading: true });
+  try {
+    const requestMethod = typeInfoORMAPI[methodName];
+    const result = await requestMethod(...args);
+    onRequestStateChange(methodName, requestId, {
+      loading: false,
+      data: result
+    });
+  } catch (error) {
+    onRequestStateChange(methodName, requestId, {
+      loading: false,
+      error: typeof error === "object" && error !== null && "message" in error ? error.message : void 0
+    });
+  }
+};
+var requestHandlerFactory = (typeInfoORMAPI, methodName, onRequestStateChange) => (...args) => {
+  const requestId = getSimpleId();
+  handleRequest(
+    requestId,
+    args,
+    typeInfoORMAPI,
+    methodName,
+    onRequestStateChange
+  );
+  return requestId;
+};
+var useTypeInfoORMAPI = (typeInfoORMAPI) => {
+  const [state, setState] = useState({});
+  const onRequestStateChange = useCallback(
+    (methodName, requestId, { loading, data, error }) => {
+      setState(
+        ({
+          [methodName]: {
+            activeRequests: prevActiveRequests = [],
+            data: prevData,
+            error: prevError
+          } = {},
+          ...prevState
+        }) => {
+          const newActiveRequests = loading ? [...prevActiveRequests, requestId] : prevActiveRequests.filter((id) => id !== requestId);
+          const currentlyLoading = newActiveRequests.length > 0;
+          return {
+            ...prevState,
+            [methodName]: {
+              activeRequests: newActiveRequests,
+              loading: currentlyLoading,
+              data: currentlyLoading ? void 0 : data ?? prevData,
+              error: currentlyLoading ? void 0 : error ?? prevError
+            }
+          };
+        }
+      );
+    },
+    []
+  );
+  const api = useMemo(() => {
+    const apiBase = {};
+    for (const aM in typeInfoORMAPI) {
+      const methodName = aM;
+      apiBase[methodName] = requestHandlerFactory(
+        typeInfoORMAPI,
+        methodName,
+        onRequestStateChange
+      );
+    }
+    return apiBase;
+  }, [typeInfoORMAPI, onRequestStateChange]);
+  return {
+    state,
+    api
+  };
+};
+
+// src/app/utils/TypeInfoORMClient.ts
+var TypeInfoORMClient = class {
+  /**
+   * Create a client for TypeInfoORM routes.
+   *
+   * @param config - Service configuration for the API routes.
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Dispatch a request to the configured service.
+   *
+   * @param path - Route path for the ORM method.
+   * @param args - Arguments to send in the request body.
+   * @returns Parsed response payload.
+   */
+  makeRequest = async (path, args) => {
+    const result = await sendServiceRequest(this.config, path, args);
+    return result;
+  };
+  /**
+   * Create an item of the provided type.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param item - Item payload to persist.
+   * @returns The created item result.
+   */
+  create = async (typeName, item) => {
+    return await this.makeRequest("create" /* CREATE */, [
+      typeName,
+      item
+    ]);
+  };
+  /**
+   * Read an item by its primary field value.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param primaryFieldValue - Primary field value to lookup.
+   * @returns The retrieved item, if found.
+   */
+  read = async (typeName, primaryFieldValue) => {
+    return await this.makeRequest("read" /* READ */, [
+      typeName,
+      primaryFieldValue
+    ]);
+  };
+  /**
+   * Update an item by replacing it with the provided payload.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param item - Updated item payload.
+   * @returns Whether the update succeeded.
+   */
+  update = async (typeName, item) => {
+    return await this.makeRequest("update" /* UPDATE */, [
+      typeName,
+      item
+    ]);
+  };
+  /**
+   * Delete an item by its primary field value.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param primaryFieldValue - Primary field value to delete.
+   * @returns Whether the delete succeeded.
+   */
+  delete = async (typeName, primaryFieldValue) => {
+    return await this.makeRequest("delete" /* DELETE */, [
+      typeName,
+      primaryFieldValue
+    ]);
+  };
+  /**
+   * List items for a given type.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param config - List configuration including filters and paging.
+   * @param selectedFields - Optional fields to project.
+   * @returns List results for the query.
+   */
+  list = async (typeName, config, selectedFields) => {
+    return await this.makeRequest("list" /* LIST */, [
+      typeName,
+      config,
+      selectedFields
+    ]);
+  };
+  /**
+   * Create a relationship between items.
+   *
+   * @param relationshipItem - Relationship payload.
+   * @returns Whether the relationship was created.
+   */
+  createRelationship = async (relationshipItem) => {
+    return await this.makeRequest(
+      "create-relationship" /* CREATE_RELATIONSHIP */,
+      [relationshipItem]
+    );
+  };
+  /**
+   * Delete a relationship between items.
+   *
+   * @param relationshipItem - Relationship payload.
+   * @returns Results describing the deletion.
+   */
+  deleteRelationship = async (relationshipItem) => {
+    return await this.makeRequest(
+      "delete-relationship" /* DELETE_RELATIONSHIP */,
+      [relationshipItem]
+    );
+  };
+  /**
+   * List relationship records matching the query.
+   *
+   * @param config - Relationship list query configuration.
+   * @returns Relationship list results.
+   */
+  listRelationships = async (config) => {
+    return await this.makeRequest("list-relationships" /* LIST_RELATIONSHIPS */, [
+      config
+    ]);
+  };
+  /**
+   * List related items for a relationship query.
+   *
+   * @param config - Relationship list query configuration.
+   * @param selectedFields - Optional fields to project on related items.
+   * @returns Related item list results.
+   */
+  listRelatedItems = async (config, selectedFields) => {
+    return await this.makeRequest("list-related-items" /* LIST_RELATED_ITEMS */, [
+      config,
+      selectedFields
+    ]);
+  };
+};
+
+export { utils_exports as Utils };