@carlonicora/nextjs-jsonapi 1.5.0 → 1.7.0

package/dist/chunk-4U5CJA44.mjs

@@ -0,0 +1,3435 @@
+import {
+  directFetch
+} from "./chunk-C7C7VY4F.mjs";
+import {
+  DataClassRegistry,
+  JsonApiDataFactory,
+  JsonApiDelete,
+  JsonApiGet,
+  JsonApiPost,
+  translateResponse
+} from "./chunk-SAL7XW2G.mjs";
+import {
+  getClientToken
+} from "./chunk-AUXK7QSA.mjs";
+import {
+  __name
+} from "./chunk-PAWJFY3S.mjs";
+
+// src/core/factories/RehydrationFactory.ts
+var RehydrationFactory = class {
+  static {
+    __name(this, "RehydrationFactory");
+  }
+  static rehydrate(classKey, data) {
+    const factoryClass = DataClassRegistry.get(classKey);
+    const instance = new factoryClass();
+    return instance.rehydrate(data);
+  }
+  static rehydrateList(classKey, data) {
+    const factoryClass = DataClassRegistry.get(classKey);
+    const response = data.map((item) => {
+      const instance = new factoryClass();
+      return instance.rehydrate(item);
+    });
+    return response;
+  }
+};
+
+// src/core/abstracts/AbstractApiData.ts
+var AbstractApiData = class {
+  static {
+    __name(this, "AbstractApiData");
+  }
+  _jsonApi;
+  _included;
+  _id;
+  _type;
+  _createdAt;
+  _updatedAt;
+  _self;
+  get type() {
+    if (!this._type) throw new Error("Type is not set.");
+    return this._type;
+  }
+  get id() {
+    if (!this._id) throw new Error("Id is not set.");
+    return this._id;
+  }
+  get self() {
+    return this._self;
+  }
+  get createdAt() {
+    return this._createdAt ?? /* @__PURE__ */ new Date();
+  }
+  get updatedAt() {
+    return this._updatedAt ?? /* @__PURE__ */ new Date();
+  }
+  get included() {
+    return this._included ?? [];
+  }
+  get jsonApi() {
+    return this._jsonApi;
+  }
+  ingestJsonApi(_data) {
+  }
+  generateApiUrl(_params) {
+    throw new Error("Method not implemented.");
+  }
+  createJsonApi(_data) {
+    throw new Error("Method not implemented.");
+  }
+  _readIncluded(data, type, dataType) {
+    if (data.included === void 0 || data.included.length === 0 || data.jsonApi.relationships === void 0 || data.jsonApi.relationships[type] === void 0 || data.jsonApi.relationships[type].data === void 0) {
+      return void 0;
+    }
+    if (Array.isArray(data.jsonApi.relationships[type].data)) {
+      const response = data.jsonApi.relationships[type].data.map((jsonApiData) => {
+        const includedData2 = data.included.find(
+          (includedData3) => includedData3.id === jsonApiData.id && includedData3.type === jsonApiData.type
+        );
+        if (includedData2 === void 0) return void 0;
+        return RehydrationFactory.rehydrate(dataType, {
+          jsonApi: includedData2,
+          included: data.included
+        });
+      });
+      return response.filter((item) => item !== void 0);
+    }
+    const includedData = data.included.find(
+      (includedData2) => includedData2.id === data.jsonApi.relationships[type].data.id && includedData2.type === data.jsonApi.relationships[type].data.type
+    );
+    if (includedData === void 0 && data.allData !== void 0) {
+      const fallbackData = data.allData.find(
+        (includedData2) => includedData2.id === data.jsonApi.relationships[type].data.id && includedData2.type === data.jsonApi.relationships[type].data.type
+      );
+      if (fallbackData !== void 0) {
+        return RehydrationFactory.rehydrate(dataType, {
+          jsonApi: fallbackData,
+          included: data.included
+        });
+      }
+    }
+    if (includedData === void 0) return void 0;
+    return RehydrationFactory.rehydrate(dataType, {
+      jsonApi: includedData,
+      included: data.included
+    });
+  }
+  dehydrate() {
+    return {
+      jsonApi: this._jsonApi,
+      included: this._included ?? []
+    };
+  }
+  rehydrate(data) {
+    this._jsonApi = data.jsonApi;
+    this._included = data.included;
+    this._type = this._jsonApi.type;
+    this._id = this._jsonApi.id;
+    this._createdAt = this._jsonApi.meta?.createdAt !== void 0 ? new Date(this._jsonApi.meta.createdAt) : void 0;
+    this._updatedAt = this._jsonApi.meta?.updatedAt !== void 0 ? new Date(this._jsonApi.meta.updatedAt) : void 0;
+    this._self = this._jsonApi.links?.self ?? void 0;
+    return this;
+  }
+};
+
+// src/core/abstracts/AbstractService.ts
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["GET"] = "GET";
+  HttpMethod2["POST"] = "POST";
+  HttpMethod2["PUT"] = "PUT";
+  HttpMethod2["PATCH"] = "PATCH";
+  HttpMethod2["DELETE"] = "DELETE";
+  return HttpMethod2;
+})(HttpMethod || {});
+var globalErrorHandler = null;
+function setGlobalErrorHandler(handler) {
+  globalErrorHandler = handler;
+}
+__name(setGlobalErrorHandler, "setGlobalErrorHandler");
+function getGlobalErrorHandler() {
+  return globalErrorHandler;
+}
+__name(getGlobalErrorHandler, "getGlobalErrorHandler");
+var AbstractService = class {
+  static {
+    __name(this, "AbstractService");
+  }
+  /**
+   * Extract locale from client-side URL pathname
+   * URL structure: /{locale}/route-path (e.g., /it/accounts)
+   * Fallback chain: URL locale → navigator.language → "en"
+   */
+  static getClientLocale() {
+    if (typeof window === "undefined") {
+      return "en";
+    }
+    const pathSegments = window.location.pathname.split("/").filter(Boolean);
+    const urlLocale = pathSegments[0];
+    const supportedLocales = ["en"];
+    if (urlLocale && supportedLocales.includes(urlLocale)) {
+      return urlLocale;
+    }
+    const navigatorLocale = navigator.language.split("-")[0];
+    if (navigatorLocale && supportedLocales.includes(navigatorLocale)) {
+      return navigatorLocale;
+    }
+    return "en";
+  }
+  static async next(params) {
+    return await this.callApi({
+      method: "GET" /* GET */,
+      type: params.type,
+      endpoint: params.endpoint,
+      next: params.next,
+      previous: params.previous,
+      self: params.self
+    });
+  }
+  /**
+   * Fetch the previous page of results.
+   */
+  static async previous(params) {
+    return await this.callApi({
+      method: "GET" /* GET */,
+      type: params.type,
+      endpoint: params.endpoint,
+      next: params.next,
+      previous: params.previous,
+      self: params.self
+    });
+  }
+  /**
+   * Make an API call with automatic environment detection and error handling.
+   */
+  static async callApi(params) {
+    const { JsonApiGet: JsonApiGet2, JsonApiPost: JsonApiPost2, JsonApiPut, JsonApiPatch, JsonApiDelete: JsonApiDelete2 } = await import("./JsonApiRequest-SYZ6FGCA.mjs");
+    let apiResponse;
+    let language = "en";
+    if (typeof window === "undefined") {
+      const { getLocale } = await import("next-intl/server");
+      language = await getLocale() ?? "en";
+    } else {
+      language = this.getClientLocale();
+    }
+    switch (params.method) {
+      case "GET" /* GET */:
+        apiResponse = await JsonApiGet2({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          language
+        });
+        break;
+      case "POST" /* POST */:
+        apiResponse = await JsonApiPost2({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          body: params.input,
+          overridesJsonApiCreation: params.overridesJsonApiCreation,
+          language,
+          responseType: params.responseType,
+          files: params.files
+        });
+        break;
+      case "PUT" /* PUT */:
+        apiResponse = await JsonApiPut({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          body: params.input,
+          language,
+          responseType: params.responseType,
+          files: params.files
+        });
+        break;
+      case "PATCH" /* PATCH */:
+        apiResponse = await JsonApiPatch({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          body: params.input,
+          overridesJsonApiCreation: params.overridesJsonApiCreation,
+          language,
+          responseType: params.responseType,
+          files: params.files
+        });
+        break;
+      case "DELETE" /* DELETE */:
+        apiResponse = await JsonApiDelete2({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          language,
+          responseType: params.responseType
+        });
+        break;
+      default:
+        throw new Error("Method not found");
+    }
+    if (!apiResponse.ok) {
+      if (globalErrorHandler && typeof window !== "undefined") {
+        globalErrorHandler(apiResponse.response, apiResponse.error);
+        return void 0;
+      } else {
+        const error = new Error(`${apiResponse.response}:${apiResponse.error}`);
+        error.status = apiResponse.response;
+        error.digest = `HTTP_${apiResponse.response}`;
+        throw error;
+      }
+    }
+    if (apiResponse.next && params.next) params.next.next = apiResponse.next;
+    if (apiResponse.prev && params.previous) params.previous.previous = apiResponse.prev;
+    if (apiResponse.self && params.self) params.self.self = apiResponse.self;
+    return apiResponse.data;
+  }
+  /**
+   * Get raw JSON:API response data without deserialization.
+   */
+  static async getRawData(params) {
+    const { JsonApiGet: JsonApiGet2 } = await import("./JsonApiRequest-SYZ6FGCA.mjs");
+    let language = "en";
+    if (typeof window === "undefined") {
+      const { getLocale } = await import("next-intl/server");
+      language = await getLocale() ?? "en";
+    } else {
+      language = this.getClientLocale();
+    }
+    const apiResponse = await JsonApiGet2({
+      classKey: params.type,
+      endpoint: params.endpoint,
+      companyId: params.companyId,
+      language
+    });
+    if (!apiResponse.ok) {
+      if (globalErrorHandler && typeof window !== "undefined") {
+        globalErrorHandler(apiResponse.response, apiResponse.error);
+        return void 0;
+      } else {
+        const error = new Error(`${apiResponse.response}:${apiResponse.error}`);
+        error.status = apiResponse.response;
+        error.digest = `HTTP_${apiResponse.response}`;
+        throw error;
+      }
+    }
+    return apiResponse.raw;
+  }
+};
+
+// src/client/JsonApiClient.ts
+var _clientConfig = null;
+function configureClientJsonApi(config) {
+  _clientConfig = config;
+  if (config.bootstrapper) {
+    config.bootstrapper();
+  }
+}
+__name(configureClientJsonApi, "configureClientJsonApi");
+function getClientApiUrl() {
+  if (_clientConfig?.apiUrl) {
+    return _clientConfig.apiUrl;
+  }
+  const envUrl = process.env.NEXT_PUBLIC_API_URL;
+  if (!envUrl) {
+    throw new Error("API URL not configured. Use configureClientJsonApi() or set NEXT_PUBLIC_API_URL environment variable.");
+  }
+  return envUrl;
+}
+__name(getClientApiUrl, "getClientApiUrl");
+function getClientAppUrl() {
+  if (_clientConfig?.appUrl) {
+    return _clientConfig.appUrl;
+  }
+  const envUrl = process.env.NEXT_PUBLIC_ADDRESS;
+  if (!envUrl) {
+    throw new Error("App URL not configured. Use configureClientJsonApi({ appUrl }) or set NEXT_PUBLIC_ADDRESS environment variable.");
+  }
+  return envUrl.trim().replace(/\/+$/, "");
+}
+__name(getClientAppUrl, "getClientAppUrl");
+function getClientTrackablePages() {
+  return _clientConfig?.trackablePages ?? [];
+}
+__name(getClientTrackablePages, "getClientTrackablePages");
+function runClientBootstrapper() {
+  if (_clientConfig?.bootstrapper) {
+    _clientConfig.bootstrapper();
+  }
+}
+__name(runClientBootstrapper, "runClientBootstrapper");
+function buildClientUrl(endpoint) {
+  const apiUrl = getClientApiUrl();
+  return endpoint.startsWith("http") ? endpoint : `${apiUrl}${endpoint}`;
+}
+__name(buildClientUrl, "buildClientUrl");
+async function ClientJsonApiGet(params) {
+  runClientBootstrapper();
+  const token = await getClientToken();
+  const apiResponse = await directFetch({
+    method: "GET",
+    url: buildClientUrl(params.endpoint),
+    token,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _clientConfig?.additionalHeaders
+  });
+  return translateResponse({
+    classKey: params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language,
+    paginationHandler: /* @__PURE__ */ __name(async (endpoint) => ClientJsonApiGet({
+      classKey: params.classKey,
+      endpoint,
+      companyId: params.companyId,
+      language: params.language
+    }), "paginationHandler")
+  });
+}
+__name(ClientJsonApiGet, "ClientJsonApiGet");
+async function ClientJsonApiPost(params) {
+  runClientBootstrapper();
+  const token = await getClientToken();
+  let body = params.body;
+  if (!body) {
+    body = {};
+  } else if (params.overridesJsonApiCreation !== true) {
+    body = JsonApiDataFactory.create(params.classKey, body);
+  }
+  const apiResponse = await directFetch({
+    method: "POST",
+    url: buildClientUrl(params.endpoint),
+    token,
+    body,
+    files: params.files,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _clientConfig?.additionalHeaders
+  });
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language
+  });
+}
+__name(ClientJsonApiPost, "ClientJsonApiPost");
+async function ClientJsonApiPut(params) {
+  runClientBootstrapper();
+  const token = await getClientToken();
+  let body = params.body;
+  if (!body) {
+    body = {};
+  } else {
+    body = JsonApiDataFactory.create(params.classKey, body);
+  }
+  const apiResponse = await directFetch({
+    method: "PUT",
+    url: buildClientUrl(params.endpoint),
+    token,
+    body,
+    files: params.files,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _clientConfig?.additionalHeaders
+  });
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language
+  });
+}
+__name(ClientJsonApiPut, "ClientJsonApiPut");
+async function ClientJsonApiPatch(params) {
+  runClientBootstrapper();
+  const token = await getClientToken();
+  let body = params.body;
+  if (!body) {
+    body = {};
+  } else if (params.overridesJsonApiCreation !== true) {
+    body = JsonApiDataFactory.create(params.classKey, body);
+  }
+  const apiResponse = await directFetch({
+    method: "PATCH",
+    url: buildClientUrl(params.endpoint),
+    token,
+    body,
+    files: params.files,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _clientConfig?.additionalHeaders
+  });
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language
+  });
+}
+__name(ClientJsonApiPatch, "ClientJsonApiPatch");
+async function ClientJsonApiDelete(params) {
+  runClientBootstrapper();
+  const token = await getClientToken();
+  const apiResponse = await directFetch({
+    method: "DELETE",
+    url: buildClientUrl(params.endpoint),
+    token,
+    companyId: params.companyId,
+    language: params.language,
+    additionalHeaders: _clientConfig?.additionalHeaders
+  });
+  return translateResponse({
+    classKey: params.responseType ?? params.classKey,
+    apiResponse,
+    companyId: params.companyId,
+    language: params.language
+  });
+}
+__name(ClientJsonApiDelete, "ClientJsonApiDelete");
+
+// src/core/abstracts/ClientAbstractService.ts
+var ClientHttpMethod = /* @__PURE__ */ ((ClientHttpMethod2) => {
+  ClientHttpMethod2["GET"] = "GET";
+  ClientHttpMethod2["POST"] = "POST";
+  ClientHttpMethod2["PUT"] = "PUT";
+  ClientHttpMethod2["PATCH"] = "PATCH";
+  ClientHttpMethod2["DELETE"] = "DELETE";
+  return ClientHttpMethod2;
+})(ClientHttpMethod || {});
+var globalErrorHandler2 = null;
+function setClientGlobalErrorHandler(handler) {
+  globalErrorHandler2 = handler;
+}
+__name(setClientGlobalErrorHandler, "setClientGlobalErrorHandler");
+function getClientGlobalErrorHandler() {
+  return globalErrorHandler2;
+}
+__name(getClientGlobalErrorHandler, "getClientGlobalErrorHandler");
+var ClientAbstractService = class {
+  static {
+    __name(this, "ClientAbstractService");
+  }
+  /**
+   * Extract locale from client-side URL pathname
+   * URL structure: /{locale}/route-path (e.g., /it/accounts)
+   * Fallback chain: URL locale → navigator.language → "en"
+   */
+  static getClientLocale() {
+    if (typeof window === "undefined") {
+      return "en";
+    }
+    const pathSegments = window.location.pathname.split("/").filter(Boolean);
+    const urlLocale = pathSegments[0];
+    const supportedLocales = ["en"];
+    if (urlLocale && supportedLocales.includes(urlLocale)) {
+      return urlLocale;
+    }
+    const navigatorLocale = navigator.language.split("-")[0];
+    if (navigatorLocale && supportedLocales.includes(navigatorLocale)) {
+      return navigatorLocale;
+    }
+    return "en";
+  }
+  /**
+   * Fetch the next page of results.
+   */
+  static async next(params) {
+    return await this.callApi({
+      method: "GET" /* GET */,
+      type: params.type,
+      endpoint: params.endpoint,
+      next: params.next,
+      previous: params.previous,
+      self: params.self
+    });
+  }
+  /**
+   * Fetch the previous page of results.
+   */
+  static async previous(params) {
+    return await this.callApi({
+      method: "GET" /* GET */,
+      type: params.type,
+      endpoint: params.endpoint,
+      next: params.next,
+      previous: params.previous,
+      self: params.self
+    });
+  }
+  /**
+   * Make a client-side API call.
+   */
+  static async callApi(params) {
+    let apiResponse;
+    const language = this.getClientLocale();
+    switch (params.method) {
+      case "GET" /* GET */:
+        apiResponse = await ClientJsonApiGet({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          language
+        });
+        break;
+      case "POST" /* POST */:
+        apiResponse = await ClientJsonApiPost({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          body: params.input,
+          overridesJsonApiCreation: params.overridesJsonApiCreation,
+          language,
+          responseType: params.responseType,
+          files: params.files
+        });
+        break;
+      case "PUT" /* PUT */:
+        apiResponse = await ClientJsonApiPut({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          body: params.input,
+          language,
+          responseType: params.responseType,
+          files: params.files
+        });
+        break;
+      case "PATCH" /* PATCH */:
+        apiResponse = await ClientJsonApiPatch({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          body: params.input,
+          overridesJsonApiCreation: params.overridesJsonApiCreation,
+          language,
+          responseType: params.responseType,
+          files: params.files
+        });
+        break;
+      case "DELETE" /* DELETE */:
+        apiResponse = await ClientJsonApiDelete({
+          classKey: params.type,
+          endpoint: params.endpoint,
+          companyId: params.companyId,
+          language,
+          responseType: params.responseType
+        });
+        break;
+      default:
+        throw new Error("Method not found");
+    }
+    if (!apiResponse.ok) {
+      if (globalErrorHandler2) {
+        globalErrorHandler2(apiResponse.response, apiResponse.error);
+        return void 0;
+      } else {
+        const error = new Error(`${apiResponse.response}:${apiResponse.error}`);
+        error.status = apiResponse.response;
+        error.digest = `HTTP_${apiResponse.response}`;
+        throw error;
+      }
+    }
+    if (apiResponse.next && params.next) params.next.next = apiResponse.next;
+    if (apiResponse.prev && params.previous) params.previous.previous = apiResponse.prev;
+    if (apiResponse.self && params.self) params.self.self = apiResponse.self;
+    return apiResponse.data;
+  }
+  /**
+   * Get raw JSON:API response data without deserialization.
+   */
+  static async getRawData(params) {
+    const language = this.getClientLocale();
+    const apiResponse = await ClientJsonApiGet({
+      classKey: params.type,
+      endpoint: params.endpoint,
+      companyId: params.companyId,
+      language
+    });
+    if (!apiResponse.ok) {
+      if (globalErrorHandler2) {
+        globalErrorHandler2(apiResponse.response, apiResponse.error);
+        return void 0;
+      } else {
+        const error = new Error(`${apiResponse.response}:${apiResponse.error}`);
+        error.status = apiResponse.response;
+        error.digest = `HTTP_${apiResponse.response}`;
+        throw error;
+      }
+    }
+    return apiResponse.raw;
+  }
+};
+
+// src/core/registry/ModuleRegistrar.ts
+var ModuleRegistrar = class {
+  static {
+    __name(this, "ModuleRegistrar");
+  }
+  static _isBootstrapped = false;
+  /**
+   * Bootstrap the registry from a Modules class.
+   * Automatically detects static getters and registers their models.
+   *
+   * @param modulesClass - The Modules class with static getters
+   */
+  static bootstrap(modulesClass) {
+    if (this._isBootstrapped) return;
+    const data = Object.getOwnPropertyNames(modulesClass).filter((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(modulesClass, key);
+      return descriptor && typeof descriptor.get === "function";
+    }).map((key) => modulesClass[key]);
+    data.forEach((item) => {
+      if (item && item.model) {
+        DataClassRegistry.registerObjectClass(item, item.model);
+      }
+    });
+    this._isBootstrapped = true;
+  }
+  /**
+   * Reset the bootstrapped state. Useful for testing.
+   */
+  static reset() {
+    this._isBootstrapped = false;
+    DataClassRegistry.clear();
+  }
+};
+
+// src/core/registry/ModuleRegistry.ts
+var ModuleRegistryClass = class {
+  static {
+    __name(this, "ModuleRegistryClass");
+  }
+  _modules = /* @__PURE__ */ new Map();
+  register(name, module) {
+    this._modules.set(name, module);
+  }
+  get(name) {
+    const module = this._modules.get(name);
+    if (!module) {
+      throw new Error(`Module "${String(name)}" not registered. Call bootstrap() first.`);
+    }
+    return module;
+  }
+  findByName(moduleName) {
+    for (const module of this._modules.values()) {
+      if (module.name === moduleName) {
+        return module;
+      }
+    }
+    throw new Error(`Module not found: ${moduleName}`);
+  }
+  findByModelName(modelName) {
+    const module = this._modules.get(modelName);
+    if (!module) {
+      throw new Error(`Module not found for model: ${modelName}`);
+    }
+    return module;
+  }
+};
+var ModuleRegistry = new ModuleRegistryClass();
+var Modules = new Proxy({}, {
+  get(_, prop) {
+    if (prop === "findByName") {
+      return (name) => ModuleRegistry.findByName(name);
+    }
+    if (prop === "findByModelName") {
+      return (name) => ModuleRegistry.findByModelName(name);
+    }
+    return ModuleRegistry.get(prop);
+  }
+});
+
+// src/core/endpoint/EndpointCreator.ts
+var EndpointCreator = class {
+  static {
+    __name(this, "EndpointCreator");
+  }
+  _endpoint;
+  constructor(params) {
+    this._endpoint = {
+      endpoint: params.endpoint,
+      id: params.id,
+      childEndpoint: params.childEndpoint,
+      childId: params.childId,
+      additionalParams: params.additionalParams ?? []
+    };
+  }
+  endpoint(value) {
+    this._endpoint.endpoint = value;
+    return this;
+  }
+  id(value) {
+    this._endpoint.id = value;
+    return this;
+  }
+  childEndpoint(value) {
+    this._endpoint.childEndpoint = value;
+    return this;
+  }
+  childId(value) {
+    this._endpoint.childId = value;
+    return this;
+  }
+  set additionalParams(value) {
+    this._endpoint.additionalParams = value;
+  }
+  addAdditionalParam(key, value) {
+    if (!this._endpoint.additionalParams) this._endpoint.additionalParams = [];
+    this._endpoint.additionalParams.push({ key, value });
+    return this;
+  }
+  limitToType(selectors) {
+    this.addAdditionalParam(`include`, selectors.join(","));
+    return this;
+  }
+  limitToFields(selectors) {
+    if (selectors.length === 0) return this;
+    selectors.forEach((selector) => {
+      const fieldString = selector.fields.join(",");
+      this.addAdditionalParam(`fields[${selector.type}]`, fieldString);
+    });
+    return this;
+  }
+  generate() {
+    let additionalParams = "";
+    if (this._endpoint.additionalParams) {
+      additionalParams = this._endpoint.additionalParams.map((param) => `${param.key}=${param.value}`).join("&");
+    }
+    let response = `${this._endpoint.endpoint.name}`;
+    if (this._endpoint.id) response += `/${this._endpoint.id}`;
+    if (this._endpoint.childEndpoint) {
+      response += `/${typeof this._endpoint.childEndpoint === "string" ? this._endpoint.childEndpoint : this._endpoint.childEndpoint.name}`;
+    }
+    if (this._endpoint.childId) response += `/${this._endpoint.childId}`;
+    if (additionalParams) response += `?${additionalParams}`;
+    return response;
+  }
+};
+
+// src/core/fields/FieldSelector.ts
+function createJsonApiInclusion(dataType, fields) {
+  return {
+    type: dataType,
+    fields
+  };
+}
+__name(createJsonApiInclusion, "createJsonApiInclusion");
+
+// src/core/utils/rehydrate.ts
+function rehydrate(classKey, data) {
+  return RehydrationFactory.rehydrate(classKey, data);
+}
+__name(rehydrate, "rehydrate");
+function rehydrateList(classKey, data) {
+  return RehydrationFactory.rehydrateList(classKey, data);
+}
+__name(rehydrateList, "rehydrateList");
+
+// src/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+__name(cn, "cn");
+
+// src/utils/compose-refs.ts
+import * as React from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  }
+  if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+__name(setRef, "setRef");
+function composeRefs(...refs) {
+  return (node) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node);
+      if (!hasCleanup && typeof cleanup === "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup === "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
+    }
+  };
+}
+__name(composeRefs, "composeRefs");
+function useComposedRefs(...refs) {
+  return React.useCallback(composeRefs(...refs), refs);
+}
+__name(useComposedRefs, "useComposedRefs");
+
+// src/utils/use-mobile.tsx
+import * as React2 from "react";
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React2.useState(void 0);
+  React2.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = /* @__PURE__ */ __name(() => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    }, "onChange");
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return !!isMobile;
+}
+__name(useIsMobile, "useIsMobile");
+
+// src/utils/date-formatter.ts
+var formatDate = /* @__PURE__ */ __name((eventDate, formatOption) => {
+  const browserLocale = navigator.language || "en-US";
+  const formatPart = /* @__PURE__ */ __name((date, options) => new Intl.DateTimeFormat(browserLocale, options).format(date), "formatPart");
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - eventDate.getTime();
+  if (formatOption === "default") {
+    if (diff < 24 * 60 * 60 * 1e3) formatOption = "timeSince";
+    else formatOption = "dateTime";
+  }
+  if (formatOption === "timeSince") {
+    const seconds = Math.floor(diff / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) return `${days} days ago`;
+    if (hours > 0) return `${hours} hours ago`;
+    if (minutes > 0) return `${minutes} minutes ago`;
+    return `${seconds} seconds ago`;
+  }
+  const dateOptions = {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  };
+  const timeOptions = {
+    hour: "2-digit",
+    minute: "2-digit"
+  };
+  switch (formatOption) {
+    case "date":
+      return formatPart(eventDate, dateOptions);
+    case "time":
+      return formatPart(eventDate, timeOptions);
+    case "dateTime":
+      return `${formatPart(eventDate, dateOptions)} ${formatPart(eventDate, timeOptions)}`;
+    default:
+      throw new Error("Invalid format option");
+  }
+}, "formatDate");
+
+// src/utils/exists.ts
+var exists = /* @__PURE__ */ __name((itemOrArray) => {
+  if (!itemOrArray) return false;
+  if (Array.isArray(itemOrArray)) {
+    return itemOrArray.length > 0;
+  }
+  return true;
+}, "exists");
+
+// src/utils/table-options.ts
+import { cloneElement, createElement, Fragment } from "react";
+var TableOptions = class {
+  static {
+    __name(this, "TableOptions");
+  }
+  _components;
+  _hasPermissionToModule;
+  constructor(hasPermissionToModule) {
+    this._hasPermissionToModule = hasPermissionToModule;
+    this._components = [];
+  }
+  addOption(component, module, action) {
+    if (!component || module && action && !this._hasPermissionToModule({ module, action })) return;
+    this._components.push(component);
+  }
+  getComponents() {
+    return this._components;
+  }
+  getOptions() {
+    if (this._components.length === 0) return null;
+    const response = this._components.map(
+      (option, index) => cloneElement(option, { key: option.key ?? index })
+    );
+    return createElement(Fragment, {}, response);
+  }
+};
+function getTableOptions(params) {
+  const tableOptions = new TableOptions(params.hasPermissionToModule);
+  params.options.forEach((option) => tableOptions.addOption(option.component, option.module, option.action));
+  return tableOptions.getOptions();
+}
+__name(getTableOptions, "getTableOptions");
+function getTableComponents(params) {
+  const tableOptions = new TableOptions(params.hasPermissionToModule);
+  params.options.forEach((option) => tableOptions.addOption(option.component, option.module, option.action));
+  return tableOptions.getComponents();
+}
+__name(getTableComponents, "getTableComponents");
+
+// src/utils/schemas/user.object.schema.ts
+import { z } from "zod";
+var userObjectSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  avatar: z.string().optional()
+});
+
+// src/utils/schemas/entity.object.schema.ts
+import { z as z2 } from "zod";
+var entityObjectSchema = z2.object({
+  id: z2.uuidv4(),
+  name: z2.string()
+});
+
+// src/utils/blocknote-diff.util.ts
+var BlockNoteDiffUtil = class {
+  static {
+    __name(this, "BlockNoteDiffUtil");
+  }
+  static DEFAULT_OPTIONS = {
+    ignoreIds: false,
+    compareContent: true,
+    similarityThreshold: 0.8
+  };
+  /**
+   * Compare two BlockNote documents and return diff result
+   */
+  static diff(originalBlocks = [], newBlocks = [], options = {}) {
+    const opts = { ...this.DEFAULT_OPTIONS, ...options };
+    const originalMap = /* @__PURE__ */ new Map();
+    const newMap = /* @__PURE__ */ new Map();
+    originalBlocks.forEach((block) => {
+      if (block.id) {
+        originalMap.set(block.id, block);
+      }
+    });
+    newBlocks.forEach((block) => {
+      if (block.id) {
+        newMap.set(block.id, block);
+      }
+    });
+    const diffBlocks = [];
+    const processedNewIds = /* @__PURE__ */ new Set();
+    for (const originalBlock of originalBlocks) {
+      const blockId = originalBlock.id;
+      const processId = blockId || crypto.randomUUID();
+      const newBlock = blockId ? newMap.get(blockId) : null;
+      if (!newBlock) {
+        const removedBlock = {
+          ...originalBlock,
+          id: processId,
+          diffType: "removed",
+          diffId: `removed-${processId}`
+        };
+        diffBlocks.push(removedBlock);
+      } else {
+        if (blockId) {
+          processedNewIds.add(blockId);
+        }
+        if (this.areBlocksEqual(originalBlock, newBlock, opts)) {
+          const unchangedBlock = {
+            ...newBlock,
+            diffType: "unchanged"
+          };
+          diffBlocks.push(unchangedBlock);
+        } else {
+          const wordDiffs = this.generateWordDiffs(originalBlock.content, newBlock.content, processId);
+          const modifiedBlock = {
+            ...newBlock,
+            diffType: "modified",
+            originalContent: originalBlock.content,
+            diffId: `modified-${processId}`,
+            wordDiffs
+          };
+          diffBlocks.push(modifiedBlock);
+        }
+      }
+    }
+    for (const newBlock of newBlocks) {
+      const blockId = newBlock.id;
+      if (blockId && processedNewIds.has(blockId)) continue;
+      const generatedId = blockId || crypto.randomUUID();
+      const addedBlock = {
+        ...newBlock,
+        id: generatedId,
+        diffType: "added",
+        diffId: `added-${generatedId}`
+      };
+      diffBlocks.push(addedBlock);
+    }
+    const sortedDiffBlocks = this.sortDiffBlocks(diffBlocks, originalBlocks, newBlocks);
+    return {
+      blocks: sortedDiffBlocks,
+      hasChanges: sortedDiffBlocks.some((block) => block.diffType !== "unchanged")
+    };
+  }
+  /**
+   * Compare two blocks for equality
+   */
+  static areBlocksEqual(block1, block2, options) {
+    if (block1.type !== block2.type) {
+      return false;
+    }
+    if (!this.deepEqual(block1.props, block2.props)) {
+      return false;
+    }
+    if (options.compareContent) {
+      if (!this.deepEqual(block1.content, block2.content)) {
+        return false;
+      }
+    }
+    const children1 = block1.children || [];
+    const children2 = block2.children || [];
+    if (children1.length !== children2.length) {
+      return false;
+    }
+    for (let i = 0; i < children1.length; i++) {
+      if (!this.areBlocksEqual(children1[i], children2[i], options)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Deep equality comparison for objects
+   */
+  static deepEqual(obj1, obj2) {
+    if (obj1 === obj2) return true;
+    if (obj1 == null || obj2 == null) return obj1 === obj2;
+    if (typeof obj1 !== typeof obj2) return false;
+    if (typeof obj1 !== "object") return obj1 === obj2;
+    if (Array.isArray(obj1) !== Array.isArray(obj2)) return false;
+    if (Array.isArray(obj1)) {
+      if (obj1.length !== obj2.length) return false;
+      for (let i = 0; i < obj1.length; i++) {
+        if (!this.deepEqual(obj1[i], obj2[i])) return false;
+      }
+      return true;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) return false;
+    for (const key of keys1) {
+      if (!keys2.includes(key)) return false;
+      if (!this.deepEqual(obj1[key], obj2[key])) return false;
+    }
+    return true;
+  }
+  /**
+   * Sort diff blocks to maintain logical order
+   */
+  static sortDiffBlocks(diffBlocks, originalBlocks, newBlocks) {
+    const originalPositions = /* @__PURE__ */ new Map();
+    const newPositions = /* @__PURE__ */ new Map();
+    originalBlocks.forEach((block, index) => {
+      if (block.id) {
+        originalPositions.set(block.id, index);
+      }
+    });
+    newBlocks.forEach((block, index) => {
+      if (block.id) {
+        newPositions.set(block.id, index);
+      }
+    });
+    return diffBlocks.sort((a, b) => {
+      const aId = a.id;
+      const bId = b.id;
+      if (!aId || !bId) return 0;
+      const aPos = newPositions.get(aId) ?? originalPositions.get(aId) ?? Infinity;
+      const bPos = newPositions.get(bId) ?? originalPositions.get(bId) ?? Infinity;
+      return aPos - bPos;
+    });
+  }
+  /**
+   * Calculate similarity between two text contents
+   */
+  static calculateSimilarity(content1, content2) {
+    if (!content1 || !content2) return 0;
+    const text1 = this.extractTextFromContent(content1);
+    const text2 = this.extractTextFromContent(content2);
+    if (text1 === text2) return 1;
+    if (!text1 || !text2) return 0;
+    const maxLength = Math.max(text1.length, text2.length);
+    const distance = this.levenshteinDistance(text1, text2);
+    return 1 - distance / maxLength;
+  }
+  /**
+   * Extract plain text from BlockNote content array
+   */
+  static extractTextFromContent(content) {
+    if (!Array.isArray(content)) return "";
+    return content.map((item) => {
+      if (item.type === "text") {
+        return item.text || "";
+      }
+      return "";
+    }).join("");
+  }
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  static levenshteinDistance(str1, str2) {
+    const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+    for (let i = 0; i <= str1.length; i++) {
+      matrix[0][i] = i;
+    }
+    for (let j = 0; j <= str2.length; j++) {
+      matrix[j][0] = j;
+    }
+    for (let j = 1; j <= str2.length; j++) {
+      for (let i = 1; i <= str1.length; i++) {
+        const substitutionCost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        matrix[j][i] = Math.min(
+          matrix[j][i - 1] + 1,
+          // deletion
+          matrix[j - 1][i] + 1,
+          // insertion
+          matrix[j - 1][i - 1] + substitutionCost
+          // substitution
+        );
+      }
+    }
+    return matrix[str2.length][str1.length];
+  }
+  /**
+   * Generate word-level diffs between two content arrays
+   */
+  static generateWordDiffs(originalContent, newContent, blockId) {
+    const originalText = this.extractTextFromContent(originalContent || []);
+    const newText = this.extractTextFromContent(newContent || []);
+    if (!originalText && !newText) return [];
+    if (!originalText) {
+      return newText.split(/\s+/).filter((word) => word.trim()).map((word, index) => ({
+        type: "added",
+        text: word,
+        diffId: `${blockId}-add-${index}`,
+        accepted: false,
+        rejected: false
+      }));
+    }
+    if (!newText) {
+      return originalText.split(/\s+/).filter((word) => word.trim()).map((word, index) => ({
+        type: "removed",
+        text: word,
+        diffId: `${blockId}-remove-${index}`,
+        accepted: false,
+        rejected: false
+      }));
+    }
+    return this.diffWords(originalText, newText, blockId);
+  }
+  /**
+   * Perform word-level diff using word-only approach (no space tokenization)
+   */
+  static diffWords(text1, text2, blockId) {
+    const words1 = text1.split(/\s+/).filter((word) => word.length > 0);
+    const words2 = text2.split(/\s+/).filter((word) => word.length > 0);
+    const diffs = this.myersDiff(words1, words2);
+    const consolidatedDiffs = this.consolidateAdjacentChanges(diffs);
+    const result = [];
+    let diffIndex = 0;
+    for (let i = 0; i < consolidatedDiffs.length; i++) {
+      const diff = consolidatedDiffs[i];
+      const isLastDiff = i === consolidatedDiffs.length - 1;
+      switch (diff.type) {
+        case "equal":
+          result.push({
+            type: "unchanged",
+            text: diff.value,
+            diffId: `${blockId}-unchanged-${diffIndex++}`,
+            accepted: true,
+            rejected: false
+          });
+          if (!isLastDiff) {
+            result.push({
+              type: "unchanged",
+              text: " ",
+              diffId: `${blockId}-space-${diffIndex++}`,
+              accepted: true,
+              rejected: false
+            });
+          }
+          break;
+        case "delete":
+          if (diff.consolidated) {
+            const nextDiff = i + 1 < consolidatedDiffs.length ? consolidatedDiffs[i + 1] : null;
+            const isConsolidatedReplacement = nextDiff && nextDiff.type === "insert" && nextDiff.consolidated;
+            if (isConsolidatedReplacement) {
+              const replacementId = `${blockId}-replace-${diffIndex++}`;
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              result.push({
+                type: "added",
+                text: nextDiff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              i++;
+              if (i < consolidatedDiffs.length - 1) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            } else {
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: `${blockId}-remove-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          } else {
+            const nextDiff = i + 1 < consolidatedDiffs.length ? consolidatedDiffs[i + 1] : null;
+            const isReplacement = nextDiff && nextDiff.type === "insert" && this.areWordsSimilar(diff.value, nextDiff.value);
+            if (isReplacement) {
+              const replacementId = `${blockId}-replace-${diffIndex++}`;
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              result.push({
+                type: "added",
+                text: nextDiff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              i++;
+              if (i < consolidatedDiffs.length - 1) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            } else {
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: `${blockId}-remove-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          }
+          break;
+        case "insert":
+          if (diff.consolidated) {
+            const prevDiff = i > 0 ? consolidatedDiffs[i - 1] : null;
+            const wasProcessedAsConsolidatedReplacement = prevDiff && prevDiff.type === "delete" && prevDiff.consolidated;
+            if (!wasProcessedAsConsolidatedReplacement) {
+              result.push({
+                type: "added",
+                text: diff.value,
+                diffId: `${blockId}-add-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          } else {
+            const prevDiff = i > 0 ? consolidatedDiffs[i - 1] : null;
+            const wasProcessedAsReplacement = prevDiff && prevDiff.type === "delete" && this.areWordsSimilar(prevDiff.value, diff.value);
+            if (!wasProcessedAsReplacement) {
+              result.push({
+                type: "added",
+                text: diff.value,
+                diffId: `${blockId}-add-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          }
+          break;
+      }
+    }
+    return result;
+  }
+  /**
+  * Improved diff algorithm that better handles word insertions
+  * Uses a combination of LCS and heuristics to minimize false changes
+  */
+  static myersDiff(a, b) {
+    if (a.length === 0) {
+      return b.map((value) => ({ type: "insert", value }));
+    }
+    if (b.length === 0) {
+      return a.map((value) => ({ type: "delete", value }));
+    }
+    const dp = this.computeEditScript(a, b);
+    return this.reconstructDiff(a, b, dp);
+  }
+  /**
+   * Compute edit script using dynamic programming
+   */
+  static computeEditScript(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++) dp[i][0] = i;
+    for (let j = 0; j <= n; j++) dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (a[i - 1] === b[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1];
+        } else {
+          dp[i][j] = 1 + Math.min(
+            dp[i - 1][j],
+            // Delete from a
+            dp[i][j - 1],
+            // Insert into a
+            dp[i - 1][j - 1]
+            // Replace
+          );
+        }
+      }
+    }
+    return dp;
+  }
+  /**
+   * Reconstruct the actual diff from the DP table
+   */
+  static reconstructDiff(a, b, dp) {
+    const result = [];
+    let i = a.length;
+    let j = b.length;
+    while (i > 0 || j > 0) {
+      if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+        result.unshift({ type: "equal", value: a[i - 1] });
+        i--;
+        j--;
+      } else {
+        const deleteCost = i > 0 ? dp[i - 1][j] : Infinity;
+        const insertCost = j > 0 ? dp[i][j - 1] : Infinity;
+        const replaceCost = i > 0 && j > 0 ? dp[i - 1][j - 1] : Infinity;
+        const minCost = Math.min(deleteCost, insertCost, replaceCost);
+        if (minCost === insertCost && j > 0) {
+          result.unshift({ type: "insert", value: b[j - 1] });
+          j--;
+        } else if (minCost === deleteCost && i > 0) {
+          result.unshift({ type: "delete", value: a[i - 1] });
+          i--;
+        } else if (minCost === replaceCost && i > 0 && j > 0) {
+          if (this.areWordsSimilar(a[i - 1], b[j - 1])) {
+            result.unshift({ type: "insert", value: b[j - 1], sharedDiffId: true });
+            result.unshift({ type: "delete", value: a[i - 1], sharedDiffId: true });
+            i--;
+            j--;
+          } else {
+            result.unshift({ type: "insert", value: b[j - 1] });
+            j--;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Consolidate adjacent changes to reduce fragmentation
+   * e.g., if we have: delete "Key", insert "Key!", delete "Challenges"
+   * We can consolidate this into: replace ["Key", "Challenges"] with ["Key!"]
+   */
+  static consolidateAdjacentChanges(diffs) {
+    const result = [];
+    let i = 0;
+    while (i < diffs.length) {
+      const current = diffs[i];
+      if (current.type === "equal") {
+        result.push(current);
+        i++;
+        continue;
+      }
+      const changeSequence = [];
+      let j = i;
+      while (j < diffs.length && diffs[j].type !== "equal") {
+        changeSequence.push(diffs[j]);
+        j++;
+      }
+      if (changeSequence.length <= 1) {
+        result.push(current);
+        i++;
+        continue;
+      }
+      const shouldConsolidate = this.shouldConsolidateChanges(
+        changeSequence
+      );
+      if (shouldConsolidate) {
+        const deletedWords = changeSequence.filter((c) => c.type === "delete").map((c) => c.value);
+        const insertedWords = changeSequence.filter((c) => c.type === "insert").map((c) => c.value);
+        if (deletedWords.length > 0) {
+          result.push({
+            type: "delete",
+            value: deletedWords.join(" "),
+            consolidated: true
+          });
+        }
+        if (insertedWords.length > 0) {
+          result.push({
+            type: "insert",
+            value: insertedWords.join(" "),
+            consolidated: true
+          });
+        }
+      } else {
+        changeSequence.forEach((change) => result.push(change));
+      }
+      i = j;
+    }
+    return result;
+  }
+  /**
+   * Determine if a sequence of changes should be consolidated
+   */
+  static shouldConsolidateChanges(changes) {
+    const hasDeletes = changes.some((c) => c.type === "delete");
+    const hasInserts = changes.some((c) => c.type === "insert");
+    return hasDeletes && hasInserts;
+  }
+  /**
+   * Check if two words are similar enough to be considered a replacement
+   */
+  static areWordsSimilar(word1, word2) {
+    if (word1 === word2) return true;
+    const maxLen = Math.max(word1.length, word2.length);
+    const minLen = Math.min(word1.length, word2.length);
+    if (maxLen > minLen * 2) {
+      return false;
+    }
+    const word1Clean = word1.replace(/[^\w]/g, "");
+    const word2Clean = word2.replace(/[^\w]/g, "");
+    if (word1Clean === word2Clean && word1 !== word2) {
+      return false;
+    }
+    const distance = this.levenshteinDistance(word1, word2);
+    const similarity = 1 - distance / maxLen;
+    return similarity > 0.7;
+  }
+};
+
+// src/utils/blocknote-word-diff-renderer.util.ts
+var BlockNoteWordDiffRendererUtil = class {
+  static {
+    __name(this, "BlockNoteWordDiffRendererUtil");
+  }
+  static renderWordDiffs(diffBlocks, onAcceptChange, onRejectChange, acceptedChanges, rejectedChanges) {
+    if (acceptedChanges || rejectedChanges) {
+      diffBlocks = this.updateWordDiffStates(diffBlocks, acceptedChanges, rejectedChanges);
+    }
+    return diffBlocks.map((block) => this.renderDiffBlock(block, onAcceptChange, onRejectChange));
+  }
+  static updateWordDiffStates(diffBlocks, acceptedChanges, rejectedChanges) {
+    return diffBlocks.map((block) => {
+      const updatedBlock = { ...block };
+      if (updatedBlock.diffId) {
+        updatedBlock.accepted = acceptedChanges?.has(updatedBlock.diffId) || false;
+        updatedBlock.rejected = rejectedChanges?.has(updatedBlock.diffId) || false;
+      }
+      if (updatedBlock.wordDiffs) {
+        updatedBlock.wordDiffs = updatedBlock.wordDiffs.map((wordDiff) => ({
+          ...wordDiff,
+          accepted: acceptedChanges?.has(wordDiff.diffId) || false,
+          rejected: rejectedChanges?.has(wordDiff.diffId) || false
+        }));
+      }
+      if (updatedBlock.children) {
+        updatedBlock.children = this.updateWordDiffStates(
+          updatedBlock.children,
+          acceptedChanges,
+          rejectedChanges
+        );
+      }
+      return updatedBlock;
+    });
+  }
+  static renderDiffBlock(block, onAcceptChange, onRejectChange) {
+    if (block.diffType === "modified" && block.wordDiffs) {
+      return this.renderWordLevelDiff(block, onAcceptChange, onRejectChange);
+    }
+    if (block.diffType === "added" || block.diffType === "removed") {
+      return this.renderBlockLevelDiff(block, onAcceptChange, onRejectChange);
+    }
+    const baseBlock = {
+      id: block.id || crypto.randomUUID(),
+      type: block.type || "paragraph",
+      props: this.getBlockProps(block),
+      content: Array.isArray(block.content) ? block.content : [],
+      children: block.children?.map(
+        (child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)
+      )
+    };
+    return baseBlock;
+  }
+  static renderBlockLevelDiff(block, onAcceptChange, onRejectChange) {
+    if (!block.diffId) {
+      return {
+        id: block.id || crypto.randomUUID(),
+        type: block.type || "paragraph",
+        props: block.props || {},
+        content: Array.isArray(block.content) ? block.content : [],
+        children: block.children?.map(
+          (child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)
+        )
+      };
+    }
+    const blockAccepted = block.accepted || false;
+    const blockRejected = block.rejected || false;
+    let content = Array.isArray(block.content) ? [...block.content] : [];
+    if (block.diffType === "added") {
+      if (blockRejected) {
+        return {
+          id: block.id || crypto.randomUUID(),
+          type: "paragraph",
+          props: {},
+          content: [],
+          children: []
+        };
+      } else if (!blockAccepted) {
+        content = content.map((item) => ({
+          ...item,
+          styles: { ...item.styles, bold: true }
+        }));
+        content.push({
+          type: "diffActions",
+          props: { diffIds: block.diffId }
+        });
+      }
+    } else if (block.diffType === "removed") {
+      if (blockAccepted) {
+        return {
+          id: block.id || crypto.randomUUID(),
+          type: "paragraph",
+          props: {},
+          content: [],
+          children: []
+        };
+      } else if (!blockRejected) {
+        content = content.map((item) => ({
+          ...item,
+          styles: { ...item.styles, strike: true }
+        }));
+        content.push({
+          type: "diffActions",
+          props: { diffIds: block.diffId }
+        });
+      }
+    }
+    const baseBlock = {
+      id: block.id || crypto.randomUUID(),
+      type: block.type || "paragraph",
+      props: this.getBlockProps(block),
+      content,
+      children: block.children?.map(
+        (child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)
+      )
+    };
+    return baseBlock;
+  }
+  static renderWordLevelDiff(block, onAcceptChange, onRejectChange) {
+    if (!block.wordDiffs) {
+      return {
+        id: block.id || crypto.randomUUID(),
+        type: block.type || "paragraph",
+        props: block.props || {},
+        content: Array.isArray(block.content) ? block.content : [],
+        children: []
+      };
+    }
+    const content = this.groupAndRenderWordDiffs(block.wordDiffs);
+    return {
+      id: block.id || crypto.randomUUID(),
+      type: block.type || "paragraph",
+      props: block.props || {},
+      content: Array.isArray(content) ? content : [],
+      children: block.children?.map((child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)) || []
+    };
+  }
+  static groupAndRenderWordDiffs(wordDiffs) {
+    const content = [];
+    for (let i = 0; i < wordDiffs.length; i++) {
+      const wordDiff = wordDiffs[i];
+      const isLastOfGroup = this.isLastDiffInGroup(wordDiffs, i);
+      const textContent = this.createTextContent(wordDiff, isLastOfGroup);
+      if (textContent) {
+        if (Array.isArray(textContent)) {
+          content.push(...textContent);
+        } else {
+          content.push(textContent);
+        }
+      }
+    }
+    const cleanedContent = this.cleanupSpaces(content);
+    return cleanedContent;
+  }
+  static cleanupSpaces(content) {
+    const filtered = content.filter((item) => item !== null && item !== void 0);
+    const cleaned = [];
+    for (let i = 0; i < filtered.length; i++) {
+      const current = filtered[i];
+      if (current.type === "text" && current.text === " ") {
+        const lastItem = cleaned[cleaned.length - 1];
+        if (i === 0 || i === filtered.length - 1 || lastItem && lastItem.type === "text" && lastItem.text === " " || lastItem && lastItem.type === "diffActions") {
+          continue;
+        }
+      }
+      if (current.type === "diffActions") {
+        const nextItem = i + 1 < filtered.length ? filtered[i + 1] : null;
+        cleaned.push(current);
+        if (nextItem && nextItem.type === "text" && nextItem.text !== " " && nextItem.type !== "diffActions") {
+          cleaned.push({
+            type: "text",
+            text: " ",
+            styles: {}
+          });
+        }
+        continue;
+      }
+      cleaned.push(current);
+    }
+    return cleaned;
+  }
+  static isLastDiffInGroup(wordDiffs, currentIndex) {
+    const currentDiff = wordDiffs[currentIndex];
+    if (currentDiff.type === "unchanged") {
+      return false;
+    }
+    for (let i = currentIndex + 1; i < wordDiffs.length; i++) {
+      const nextDiff = wordDiffs[i];
+      if (nextDiff.diffId === currentDiff.diffId && (nextDiff.type === "added" || nextDiff.type === "removed")) {
+        return false;
+      }
+      if (nextDiff.type !== "unchanged" && nextDiff.diffId !== currentDiff.diffId) {
+        break;
+      }
+    }
+    return true;
+  }
+  static createTextContent(wordDiff, isLastOfGroup) {
+    switch (wordDiff.type) {
+      case "added":
+        if (wordDiff.accepted) {
+          return {
+            type: "text",
+            text: wordDiff.text,
+            styles: {}
+          };
+        } else if (wordDiff.rejected) {
+          return null;
+        } else {
+          if (wordDiff.text.trim() === "") {
+            return {
+              type: "text",
+              text: wordDiff.text,
+              styles: { backgroundColor: "#dcfce7" }
+            };
+          } else {
+            const baseContent = {
+              type: "text",
+              text: wordDiff.text,
+              styles: { bold: true }
+            };
+            if (isLastOfGroup) {
+              return [
+                baseContent,
+                {
+                  type: "diffActions",
+                  props: { diffIds: wordDiff.diffId }
+                }
+              ];
+            } else {
+              return baseContent;
+            }
+          }
+        }
+      case "removed":
+        if (wordDiff.accepted) {
+          return null;
+        } else if (wordDiff.rejected) {
+          return {
+            type: "text",
+            text: wordDiff.text,
+            styles: {}
+          };
+        } else {
+          if (wordDiff.text.trim() === "") {
+            return {
+              type: "text",
+              text: wordDiff.text,
+              styles: { strike: true }
+            };
+          } else {
+            const baseContent = {
+              type: "text",
+              text: wordDiff.text,
+              styles: { strike: true }
+            };
+            if (isLastOfGroup) {
+              return [
+                baseContent,
+                {
+                  type: "diffActions",
+                  props: { diffIds: wordDiff.diffId }
+                }
+              ];
+            } else {
+              return baseContent;
+            }
+          }
+        }
+      case "unchanged":
+      default:
+        return {
+          type: "text",
+          text: wordDiff.text,
+          styles: {}
+        };
+    }
+  }
+  static getBlockProps(block) {
+    const baseProps = block.props || {};
+    return baseProps;
+  }
+  static generateChangeSummary(diffBlocks) {
+    let totalWords = 0;
+    let addedWords = 0;
+    let removedWords = 0;
+    let acceptedChanges = 0;
+    let rejectedChanges = 0;
+    let pendingChanges = 0;
+    const processBlock = /* @__PURE__ */ __name((block) => {
+      if (block.wordDiffs) {
+        block.wordDiffs.forEach((wordDiff) => {
+          totalWords++;
+          if (wordDiff.type === "added") {
+            addedWords++;
+          } else if (wordDiff.type === "removed") {
+            removedWords++;
+          }
+          if (wordDiff.accepted) {
+            acceptedChanges++;
+          } else if (wordDiff.rejected) {
+            rejectedChanges++;
+          } else if (wordDiff.type !== "unchanged") {
+            pendingChanges++;
+          }
+        });
+      }
+      if (block.children) {
+        block.children.forEach((child) => processBlock(child));
+      }
+    }, "processBlock");
+    diffBlocks.forEach(processBlock);
+    return {
+      totalWords,
+      addedWords,
+      removedWords,
+      acceptedChanges,
+      rejectedChanges,
+      pendingChanges
+    };
+  }
+};
+
+// src/utils/icons.tsx
+import { jsx } from "react/jsx-runtime";
+var getIconByModule = /* @__PURE__ */ __name((params) => {
+  const IconComponent = getLucideIconByModule({ module: params.module });
+  if (!IconComponent) return null;
+  return /* @__PURE__ */ jsx(IconComponent, { className: cn(``, params.className) });
+}, "getIconByModule");
+var getIcon = /* @__PURE__ */ __name((params) => {
+  const IconComponent = getLucideIcon({ element: params.element });
+  if (!IconComponent) return null;
+  return /* @__PURE__ */ jsx(IconComponent, { className: cn(``, params.className) });
+}, "getIcon");
+var getIconByModuleName = /* @__PURE__ */ __name((params) => {
+  return getIconByModule({ module: Modules.findByModelName(params.name), className: params.className });
+}, "getIconByModuleName");
+var getLucideIcon = /* @__PURE__ */ __name((params) => {
+  if (params.element.type === "contents") {
+    const contentType = params.element.contentType;
+    if (!contentType) return null;
+    return getLucideIconByModule({ module: Modules.findByModelName(contentType) });
+  }
+  return getLucideIconByModule({ module: Modules.findByName(params.element.type) });
+}, "getLucideIcon");
+var getLucideIconByModule = /* @__PURE__ */ __name((params) => {
+  return params.module.icon ?? null;
+}, "getLucideIconByModule");
+var getLucideIconByModuleName = /* @__PURE__ */ __name((params) => {
+  return getLucideIconByModule({ module: Modules.findByModelName(params.name) });
+}, "getLucideIconByModuleName");
+
+// src/permissions/types.ts
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2["Read"] = "read";
+  Action2["Create"] = "create";
+  Action2["Update"] = "update";
+  Action2["Delete"] = "delete";
+  return Action2;
+})(Action || {});
+
+// src/permissions/check.ts
+function checkPermissions(params) {
+  const selectedModule = params.user.modules.find((module) => module.id === params.module.moduleId);
+  if (!selectedModule) return false;
+  const permissionConfig = selectedModule.permissions[params.action];
+  if (!permissionConfig) return false;
+  if (typeof permissionConfig === "boolean") return permissionConfig;
+  if (!params.data) return true;
+  try {
+    const singlePermissionConfig = permissionConfig.split("|").map((p) => p.trim());
+    for (const path of singlePermissionConfig) {
+      if (getValueFromPath(params.data, path, params.user.id)) return true;
+    }
+    return false;
+  } catch {
+    if (typeof permissionConfig === "string") {
+      return getValueFromPath(params.data, permissionConfig, params.user.id);
+    }
+  }
+  return false;
+}
+__name(checkPermissions, "checkPermissions");
+function checkPermissionsFromServer(params) {
+  if (!params.selectedModule) return false;
+  const permissionConfig = params.selectedModule.permissions[params.action];
+  if (!permissionConfig) return false;
+  if (typeof permissionConfig === "boolean") return permissionConfig;
+  if (!params.data) return true;
+  try {
+    const singlePermissionConfig = permissionConfig.split("|").map((p) => p.trim());
+    for (const path of singlePermissionConfig) {
+      if (getValueFromPath(params.data, path, params.userId)) return true;
+    }
+    return false;
+  } catch {
+    if (typeof permissionConfig === "string") {
+      return getValueFromPath(params.data, permissionConfig, params.userId);
+    }
+  }
+  return false;
+}
+__name(checkPermissionsFromServer, "checkPermissionsFromServer");
+function getValueFromPath(obj, path, userId) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!current) return false;
+    if (Array.isArray(current)) {
+      let found = false;
+      for (const item of current) {
+        const result = getValueFromPath(item, parts.slice(parts.indexOf(part)).join("."), userId);
+        if (result === userId || result === true) {
+          found = true;
+          break;
+        }
+      }
+      return found;
+    } else if (current[part] !== void 0) {
+      current = current[part];
+    } else {
+      return false;
+    }
+  }
+  if (Array.isArray(current)) {
+    return current.some((item) => {
+      if (typeof item === "object" && item.id !== void 0) {
+        return item.id.toString() === userId;
+      }
+      return item.toString() === userId;
+    });
+  }
+  if (typeof current === "object" && current.id !== void 0) {
+    return current.id.toString() === userId;
+  }
+  return current.toString() === userId;
+}
+__name(getValueFromPath, "getValueFromPath");
+
+// src/features/auth/data/auth.ts
+var Auth = class extends AbstractApiData {
+  static {
+    __name(this, "Auth");
+  }
+  _token;
+  _refreshToken;
+  _user;
+  get token() {
+    if (!this._token) throw new Error("Token is not defined");
+    return this._token;
+  }
+  get refreshToken() {
+    if (!this._refreshToken) throw new Error("Refresh token is not defined");
+    return this._refreshToken;
+  }
+  get user() {
+    if (!this._user) throw new Error("User is not defined");
+    return this._user;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._token = data.jsonApi.attributes.token ?? void 0;
+    this._refreshToken = data.jsonApi.attributes.refreshToken ?? void 0;
+    this._user = this._readIncluded(data, "user", Modules.User);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.Auth.name,
+        attributes: {}
+      }
+    };
+    if (data.id) response.data.id = data.id;
+    if (data.email !== void 0) response.data.attributes.email = data.email;
+    if (data.name !== void 0) response.data.attributes.name = data.name;
+    if (data.companyName !== void 0) response.data.attributes.companyName = data.companyName;
+    if (data.password !== void 0) response.data.attributes.password = data.password;
+    if (data.partitaIva !== void 0) response.data.attributes.partitaIva = data.partitaIva;
+    if (data.codiceFiscale !== void 0) response.data.attributes.codiceFiscale = data.codiceFiscale;
+    return response;
+  }
+};
+
+// src/features/auth/config.ts
+var _tokenHandler = null;
+function configureAuth(handler) {
+  _tokenHandler = handler;
+}
+__name(configureAuth, "configureAuth");
+function getTokenHandler() {
+  return _tokenHandler;
+}
+__name(getTokenHandler, "getTokenHandler");
+
+// src/features/auth/data/auth.service.ts
+var AuthService = class extends AbstractService {
+  static {
+    __name(this, "AuthService");
+  }
+  static async login(params) {
+    const language = params.language || "en-US";
+    const apiResponse = await JsonApiPost({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "login" }).generate(),
+      body: { email: params.email, password: params.password },
+      language
+    });
+    if (!apiResponse.ok) throw new Error(apiResponse.error);
+    const auth = apiResponse.data;
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.updateToken({
+        token: auth.token,
+        refreshToken: auth.refreshToken,
+        userId: auth.user.id,
+        companyId: auth.user.company?.id,
+        licenseExpirationDate: auth.user.company?.licenseExpirationDate,
+        roles: auth.user.roles.map((role) => role.id),
+        features: auth.user.company?.features?.map((feature) => feature.id) ?? [],
+        modules: auth.user.modules.map((module) => ({
+          id: module.id,
+          permissions: module.permissions
+        }))
+      });
+    }
+    return auth.user;
+  }
+  static async logout(params) {
+    const language = params?.language || "en-US";
+    await JsonApiDelete({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth }).generate(),
+      language
+    });
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.removeToken();
+    }
+  }
+  static async initialiseForgotPassword(params) {
+    const language = params.language || "en-US";
+    const response = await JsonApiPost({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "forgot" }).generate(),
+      body: { email: params.email },
+      language
+    });
+    if (!response.ok) {
+      throw new Error(response.error);
+    }
+  }
+  static async register(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "register" });
+    await this.callApi({
+      type: Modules.Auth,
+      method: "POST" /* POST */,
+      endpoint: endpoint.generate(),
+      input: params
+    });
+  }
+  static async activate(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Auth,
+      id: "activate",
+      childEndpoint: params.activationCode
+    });
+    await this.callApi({ type: Modules.Auth, method: "POST" /* POST */, endpoint: endpoint.generate() });
+  }
+  static async validateCode(params) {
+    const language = params.language || "en-US";
+    const apiResponse = await JsonApiGet({
+      classKey: Modules.Auth,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth, id: "validate", childEndpoint: params.code }).generate(),
+      language
+    });
+    if (!apiResponse.ok) throw new Error(apiResponse.error);
+  }
+  static async resetPassword(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "reset", childEndpoint: params.code });
+    const input = { password: params.password };
+    await this.callApi({ type: Modules.Auth, method: "POST" /* POST */, endpoint: endpoint.generate(), input });
+  }
+  static async acceptInvitation(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Auth, id: "invitation", childEndpoint: params.code });
+    const input = { password: params.password };
+    await this.callApi({ type: Modules.Auth, method: "POST" /* POST */, endpoint: endpoint.generate(), input });
+  }
+  static async findToken(params) {
+    return await this.callApi({
+      type: Modules.Auth,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Auth }).addAdditionalParam("code", params.tokenCode).generate()
+    });
+  }
+  static async saveToken(params) {
+    const auth = rehydrate(Modules.Auth, params.dehydratedAuth);
+    const handler = getTokenHandler();
+    if (handler) {
+      await handler.updateToken({
+        token: auth.token,
+        refreshToken: auth.refreshToken,
+        userId: auth.user.id,
+        companyId: auth.user.company?.id,
+        licenseExpirationDate: auth.user.company?.licenseExpirationDate,
+        roles: auth.user.roles.map((role) => role.id),
+        features: auth.user.company?.features?.map((feature) => feature.id) ?? [],
+        modules: auth.user.modules.map((module) => ({
+          id: module.id,
+          permissions: module.permissions
+        }))
+      });
+    }
+  }
+};
+
+// src/features/auth/enums/AuthComponent.ts
+var AuthComponent = /* @__PURE__ */ ((AuthComponent2) => {
+  AuthComponent2[AuthComponent2["Login"] = 0] = "Login";
+  AuthComponent2[AuthComponent2["ForgotPassword"] = 1] = "ForgotPassword";
+  AuthComponent2[AuthComponent2["ResetPassword"] = 2] = "ResetPassword";
+  AuthComponent2[AuthComponent2["ActivateAccount"] = 3] = "ActivateAccount";
+  AuthComponent2[AuthComponent2["AcceptInvitation"] = 4] = "AcceptInvitation";
+  AuthComponent2[AuthComponent2["Register"] = 5] = "Register";
+  AuthComponent2[AuthComponent2["Landing"] = 6] = "Landing";
+  return AuthComponent2;
+})(AuthComponent || {});
+
+// src/features/auth/auth.module.ts
+var AuthModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/auth",
+  name: "auth",
+  model: Auth
+}), "AuthModule");
+
+// src/features/company/data/company.ts
+var Company = class extends AbstractApiData {
+  static {
+    __name(this, "Company");
+  }
+  _name;
+  _logo;
+  _logoUrl;
+  _configurations;
+  _licenseExpirationDate;
+  _features;
+  _modules;
+  get name() {
+    if (this._name === void 0) throw new Error("Name is not defined");
+    return this._name;
+  }
+  get logo() {
+    return this._logo;
+  }
+  get logoUrl() {
+    return this._logoUrl;
+  }
+  get licenseExpirationDate() {
+    return this._licenseExpirationDate;
+  }
+  get features() {
+    return this._features ?? [];
+  }
+  get modules() {
+    return this._modules ?? [];
+  }
+  get configurations() {
+    return this._configurations;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._name = data.jsonApi.attributes.name;
+    this._configurations = data.jsonApi.attributes.configurations ? JSON.parse(data.jsonApi.attributes.configurations) : void 0;
+    this._logo = data.jsonApi.attributes.logo;
+    this._logoUrl = data.jsonApi.attributes.logoUrl;
+    this._licenseExpirationDate = data.jsonApi.attributes.licenseExpirationDate ? new Date(data.jsonApi.attributes.licenseExpirationDate) : void 0;
+    this._features = this._readIncluded(data, "features", Modules.Feature);
+    this._modules = this._readIncluded(data, "modules", Modules.Module);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.Company.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.name) response.data.attributes.name = data.name;
+    if (data.configurations) response.data.attributes.configurations = JSON.stringify(data.configurations);
+    if (data.logo) response.data.attributes.logo = data.logo;
+    if (data.license) response.data.attributes.license = data.license;
+    if (data.privateKey) response.data.attributes.privateKey = data.privateKey;
+    if (data.featureIds && data.featureIds.length > 0) {
+      response.data.relationships.features = {
+        data: data.featureIds.map((featureId) => ({
+          type: Modules.Feature.name,
+          id: featureId
+        }))
+      };
+    }
+    if (data.moduleIds && data.moduleIds.length > 0) {
+      response.data.relationships.modules = {
+        data: data.moduleIds.map((moduleId) => ({
+          type: Modules.Module.name,
+          id: moduleId
+        }))
+      };
+    }
+    return response;
+  }
+};
+
+// src/features/company/data/company.fields.ts
+var CompanyFields = /* @__PURE__ */ ((CompanyFields2) => {
+  CompanyFields2["companyId"] = "companyId";
+  CompanyFields2["name"] = "name";
+  CompanyFields2["createdAt"] = "createdAt";
+  CompanyFields2["updatedAt"] = "updatedAt";
+  return CompanyFields2;
+})(CompanyFields || {});
+
+// src/features/company/data/company.service.ts
+var CompanyService = class extends AbstractService {
+  static {
+    __name(this, "CompanyService");
+  }
+  static async findOne(params) {
+    return this.callApi({
+      type: Modules.Company,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.companyId }).generate()
+    });
+  }
+  static async findMany(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Company });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.Company,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.Company,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.companyId }).generate()
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.Company,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company }).generate(),
+      input: params
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.Company,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.id }).generate(),
+      input: params
+    });
+  }
+  static async updateConfigurations(params) {
+    return this.callApi({
+      type: Modules.Company,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Company,
+        id: params.id,
+        childEndpoint: "configurations"
+      }).generate(),
+      input: params
+    });
+  }
+  static async activateLicense(params) {
+    return this.callApi({
+      type: Modules.Company,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.id, childEndpoint: "license" }).generate(),
+      input: params
+    });
+  }
+};
+
+// src/features/company/company.module.ts
+var CompanyModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/companies",
+  name: "companies",
+  model: Company,
+  moduleId: "f9e77c8f-bfd1-4fd4-80b0-e1d891ab7113"
+}), "CompanyModule");
+
+// src/features/content/data/content.ts
+var Content = class extends AbstractApiData {
+  static {
+    __name(this, "Content");
+  }
+  _contentType;
+  _name;
+  _abstract;
+  _tldr;
+  _aiStatus;
+  _relevance;
+  _author;
+  _editors;
+  get searchResult() {
+    return this._name ?? "";
+  }
+  get contentType() {
+    return this._contentType;
+  }
+  get name() {
+    if (this._name === void 0) throw new Error("JsonApi error: content name is missing");
+    return this._name;
+  }
+  get abstract() {
+    return this._abstract;
+  }
+  get tldr() {
+    return this._tldr;
+  }
+  get aiStatus() {
+    return this._aiStatus ?? "";
+  }
+  get relevance() {
+    return this._relevance;
+  }
+  get author() {
+    if (this._author === void 0) throw new Error("JsonApi error: document author is missing");
+    return this._author;
+  }
+  get editors() {
+    return this._editors ?? [];
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._contentType = data.jsonApi.meta.contentType;
+    this._name = data.jsonApi.attributes.name;
+    this._abstract = data.jsonApi.attributes.abstract;
+    this._tldr = data.jsonApi.attributes.tldr;
+    this._aiStatus = data.jsonApi.meta.aiStatus;
+    this._relevance = data.jsonApi.meta.relevance;
+    this._author = this._readIncluded(data, "author", Modules.User);
+    this._editors = this._readIncluded(data, "editors", Modules.User);
+    return this;
+  }
+  addContentInput(response, data) {
+    if (data.name) response.data.attributes.name = data.name;
+    if (data.authorId) {
+      response.data.relationships.author = {
+        data: {
+          type: Modules.User.name,
+          id: data.authorId
+        }
+      };
+    }
+  }
+};
+
+// src/features/content/data/content.fields.ts
+var ContentFields = /* @__PURE__ */ ((ContentFields2) => {
+  ContentFields2["contentId"] = "contentId";
+  ContentFields2["name"] = "name";
+  ContentFields2["relevance"] = "relevance";
+  ContentFields2["authors"] = "authors";
+  ContentFields2["createdAt"] = "createdAt";
+  ContentFields2["updatedAt"] = "updatedAt";
+  return ContentFields2;
+})(ContentFields || {});
+
+// src/features/content/data/content.service.ts
+var ContentService = class extends AbstractService {
+  static {
+    __name(this, "ContentService");
+  }
+  static async findMany(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Content });
+    if (params.contentIds) {
+      endpoint.addAdditionalParam("contentIds", params.contentIds.join(","));
+      endpoint.addAdditionalParam("fetchAll", "true");
+    } else {
+      if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+      if (params.search) endpoint.addAdditionalParam("search", params.search);
+    }
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.Content,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findRelevant(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Content,
+      id: params.id,
+      childEndpoint: "relevance"
+    });
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.Content,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findManyByAuthor(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Author,
+      id: params.userId,
+      childEndpoint: Modules.Content
+    });
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.Content,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+};
+
+// src/features/content/content.module.ts
+var ContentModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/contents",
+  name: "contents",
+  model: Content,
+  inclusions: {
+    lists: {
+      fields: [
+        createJsonApiInclusion("content", [`name`, `tldr`, `abstract`, `aiStatus`, `relevance`]),
+        createJsonApiInclusion("users", [`name`, `avatar`]),
+        createJsonApiInclusion("topics", [`name`]),
+        createJsonApiInclusion("expertises", [`name`])
+      ]
+    }
+  }
+}), "ContentModule");
+
+// src/features/feature/data/feature.ts
+var Feature = class extends AbstractApiData {
+  static {
+    __name(this, "Feature");
+  }
+  _name;
+  _isProduction;
+  _modules = [];
+  get name() {
+    return this._name ?? "";
+  }
+  get isProduction() {
+    return this._isProduction == true ? true : false;
+  }
+  get modules() {
+    return this._modules;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._name = data.jsonApi.attributes.name;
+    this._isProduction = data.jsonApi.attributes.isProduction ?? false;
+    this._modules = this._readIncluded(data, `modules`, Modules.Module);
+    return this;
+  }
+};
+
+// src/features/feature/data/feature.service.ts
+var FeatureService = class extends AbstractService {
+  static {
+    __name(this, "FeatureService");
+  }
+  static async findMany(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Feature });
+    if (params.companyId) endpoint.endpoint(Modules.Company).id(params.companyId).childEndpoint(Modules.Feature);
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.Feature,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+};
+
+// src/features/feature/feature.module.ts
+var FeatureModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/features",
+  name: "features",
+  model: Feature,
+  moduleId: "025fdd23-2803-4360-9fd9-eaa3612c2e23"
+}), "FeatureModule");
+
+// src/features/module/data/module.ts
+var Module = class extends AbstractApiData {
+  static {
+    __name(this, "Module");
+  }
+  _name;
+  _isCore;
+  _permissions;
+  get name() {
+    if (!this._name) throw new Error("Name is not defined");
+    return this._name ?? "";
+  }
+  get isCore() {
+    return this._isCore ?? false;
+  }
+  get permissions() {
+    if (!this._permissions) throw new Error("Permissions is not defined");
+    return this._permissions;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._name = data.jsonApi.attributes.name;
+    this._isCore = data.jsonApi.attributes.isCore;
+    this._permissions = data.jsonApi.meta.permissions;
+    return this;
+  }
+};
+
+// src/features/module/module.module.ts
+var ModuleModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/modules",
+  name: "modules",
+  model: Module,
+  moduleId: "25ffd868-8341-4ca7-963b-6e1c56b03b1d"
+}), "ModuleModule");
+
+// src/features/notification/data/notification.ts
+var Notification = class extends AbstractApiData {
+  static {
+    __name(this, "Notification");
+  }
+  _notificationType;
+  _isRead;
+  _actor;
+  get notificationType() {
+    if (this._notificationType === void 0) throw new Error("notificationType is not set");
+    return this._notificationType;
+  }
+  get isRead() {
+    return this._isRead === void 0 ? false : this._isRead;
+  }
+  get actor() {
+    return this._actor;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._notificationType = data.jsonApi.attributes.notificationType;
+    this._isRead = data.jsonApi.attributes.isRead;
+    this._actor = this._readIncluded(data, "actor", Modules.User);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.Notification.name,
+        id: data.id,
+        attributes: {
+          isRead: data.isRead
+        },
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    return response;
+  }
+};
+
+// src/features/notification/data/notification.fields.ts
+var NotificationFields = /* @__PURE__ */ ((NotificationFields2) => {
+  NotificationFields2["notificationId"] = "notificationId";
+  NotificationFields2["name"] = "name";
+  NotificationFields2["createdAt"] = "createdAt";
+  NotificationFields2["updatedAt"] = "updatedAt";
+  return NotificationFields2;
+})(NotificationFields || {});
+
+// src/features/notification/data/notification.service.ts
+var NotificationService = class extends AbstractService {
+  static {
+    __name(this, "NotificationService");
+  }
+  static async findMany(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification });
+    if (params.isArchived) endpoint.addAdditionalParam("isArchived", "true");
+    return this.callApi({
+      type: Modules.Notification,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async markAsRead(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification });
+    await this.callApi({
+      type: Modules.Notification,
+      method: "PATCH" /* PATCH */,
+      endpoint: endpoint.generate(),
+      input: params.data,
+      overridesJsonApiCreation: true
+    });
+  }
+  static async archive(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification, id: params.id, childEndpoint: "archive" });
+    await this.callApi({ type: Modules.Notification, method: "POST" /* POST */, endpoint: endpoint.generate() });
+  }
+};
+
+// src/features/notification/notification.module.ts
+var NotificationModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/notifications",
+  name: "notifications",
+  model: Notification,
+  moduleId: "9259d704-c670-4e77-a3a1-a728ffc5be3d"
+}), "NotificationModule");
+
+// src/features/push/data/push.ts
+var Push = class extends AbstractApiData {
+  static {
+    __name(this, "Push");
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.Push.name,
+        attributes: {
+          key: data.key
+        }
+      },
+      included: []
+    };
+    return response;
+  }
+};
+
+// src/features/push/data/push.service.ts
+var PushService = class extends AbstractService {
+  static {
+    __name(this, "PushService");
+  }
+  static async register(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Push });
+    await this.callApi({
+      type: Modules.Push,
+      method: "POST" /* POST */,
+      endpoint: endpoint.generate(),
+      input: params.data,
+      overridesJsonApiCreation: true
+    });
+  }
+};
+
+// src/features/push/push.module.ts
+var PushModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/push",
+  name: "push",
+  model: Push,
+  moduleId: ""
+}), "PushModule");
+
+// src/features/role/data/role.ts
+var Role = class extends AbstractApiData {
+  static {
+    __name(this, "Role");
+  }
+  _name;
+  _description;
+  _isSelectable;
+  _requiredFeature;
+  get name() {
+    if (!this._name) throw new Error("Name is not defined");
+    return this._name;
+  }
+  get description() {
+    return this._description ?? "";
+  }
+  get isSelectable() {
+    return this._isSelectable ?? false;
+  }
+  get requiredFeature() {
+    return this._requiredFeature;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._name = data.jsonApi.attributes.name ?? void 0;
+    this._description = data.jsonApi.attributes.description ?? void 0;
+    this._isSelectable = data.jsonApi.attributes.isSelectable ?? void 0;
+    this._requiredFeature = this._readIncluded(
+      data,
+      "requiredFeature",
+      Modules.Feature
+    );
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.Role.name,
+        id: data.id,
+        attributes: {
+          name: data.name
+        },
+        meta: {}
+      },
+      included: []
+    };
+    if (data.description !== void 0) response.data.attributes.description = data.description;
+    return response;
+  }
+};
+
+// src/features/role/data/role.fields.ts
+var RoleFields = /* @__PURE__ */ ((RoleFields2) => {
+  RoleFields2["roleId"] = "roleId";
+  RoleFields2["name"] = "name";
+  RoleFields2["description"] = "description";
+  RoleFields2["createdAt"] = "createdAt";
+  RoleFields2["updatedAt"] = "updatedAt";
+  return RoleFields2;
+})(RoleFields || {});
+
+// src/features/role/data/role.service.ts
+var RoleService = class extends AbstractService {
+  static {
+    __name(this, "RoleService");
+  }
+  static async findById(params) {
+    return this.callApi({
+      type: Modules.Role,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate()
+    });
+  }
+  static async findAllRoles(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Role });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.Role,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findAllRolesByUser(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: params.userId, childEndpoint: Modules.Role });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.Role,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findAllRolesUserNotIn(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.User,
+      id: params.userId,
+      childEndpoint: Modules.Role
+    }).addAdditionalParam("userNotIn", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.Role,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async addUserToRole(params) {
+    this.callApi({
+      type: Modules.Role,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Role,
+        id: params.roleId,
+        childEndpoint: Modules.User,
+        childId: params.userId
+      }).generate()
+    });
+  }
+  static async removeUserFromRole(params) {
+    this.callApi({
+      type: Modules.Role,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Role,
+        id: params.roleId,
+        childEndpoint: Modules.User,
+        childId: params.userId
+      }).generate()
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.Role,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role }).generate(),
+      input: { id: params.roleId, name: params.name, description: params.description }
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.Role,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+      input: { id: params.roleId, name: params.name, description: params.description }
+    });
+  }
+  static async delete(params) {
+    return this.callApi({
+      type: Modules.Role,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate()
+    });
+  }
+};
+
+// src/features/role/role.module.ts
+var RoleModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/roles",
+  name: "roles",
+  model: Role,
+  moduleId: "9f6416e6-7b9b-4e1a-a99f-833191eca8a9"
+}), "RoleModule");
+
+// src/features/s3/data/s3.ts
+var S3 = class extends AbstractApiData {
+  static {
+    __name(this, "S3");
+  }
+  _url;
+  _storageType;
+  _contentType;
+  _blobType;
+  _acl;
+  get url() {
+    if (!this._url) throw new Error("Image URL is not set.");
+    return this._url;
+  }
+  get headers() {
+    const headers = {};
+    if (this._contentType) {
+      headers["Content-Type"] = this._contentType;
+    }
+    if (this._blobType) {
+      headers["x-ms-blob-type"] = this._blobType;
+    }
+    if (this._acl) {
+      headers["x-amz-acl"] = this._acl;
+    }
+    return headers;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._url = data.jsonApi.attributes.url ?? void 0;
+    this._storageType = data.jsonApi.attributes.storageType ?? void 0;
+    this._contentType = data.jsonApi.attributes.contentType ?? void 0;
+    this._blobType = data.jsonApi.attributes.blobType ?? void 0;
+    this._acl = data.jsonApi.attributes.acl ?? void 0;
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.S3.name,
+        attributes: {
+          key: data.key
+        }
+      },
+      included: []
+    };
+    if (data.contentType) response.data.attributes.contentType = data.contentType;
+    return response;
+  }
+};
+
+// src/features/s3/s3.module.ts
+var S3Module = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/s3",
+  name: "s3",
+  model: S3,
+  moduleId: "db41ba46-e171-4324-8845-99353eba8568"
+}), "S3Module");
+
+// src/features/s3/data/s3.service.ts
+var S3Service = class extends AbstractService {
+  static {
+    __name(this, "S3Service");
+  }
+  static async getPreSignedUrl(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.S3 }).addAdditionalParam("key", params.key).addAdditionalParam("contentType", params.contentType);
+    if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
+    return this.callApi({ type: Modules.S3, method: "GET" /* GET */, endpoint: endpoint.generate() });
+  }
+  static async getSignedUrl(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.S3, id: "sign" }).addAdditionalParam("key", params.key);
+    if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
+    return this.callApi({ type: Modules.S3, method: "GET" /* GET */, endpoint: endpoint.generate() });
+  }
+  static async deleteFile(params) {
+    this.callApi({
+      type: Modules.S3,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.S3 }).addAdditionalParam("key", params.key).generate()
+    });
+  }
+};
+
+// src/features/user/data/user.ts
+var User = class extends AbstractApiData {
+  static {
+    __name(this, "User");
+  }
+  _name;
+  _email;
+  _title;
+  _bio;
+  _avatar;
+  _avatarUrl;
+  _phone;
+  _rate;
+  _isActivated;
+  _isDeleted;
+  _lastLogin;
+  _relevance;
+  _roles = [];
+  _company;
+  _modules = [];
+  get searchResult() {
+    return this._name ?? "";
+  }
+  get name() {
+    return this._name ?? "";
+  }
+  get email() {
+    return this._email ?? "";
+  }
+  get title() {
+    return this._title ?? "";
+  }
+  get bio() {
+    return this._bio ?? "";
+  }
+  get avatar() {
+    return this._avatar;
+  }
+  get avatarUrl() {
+    return this._avatarUrl;
+  }
+  get phone() {
+    return this._phone;
+  }
+  get rate() {
+    return this._rate;
+  }
+  get relevance() {
+    return this._relevance;
+  }
+  get isActivated() {
+    return this._isActivated ?? false;
+  }
+  get isDeleted() {
+    return this._isDeleted ?? false;
+  }
+  get lastLogin() {
+    return this._lastLogin;
+  }
+  get roles() {
+    return this._roles;
+  }
+  get company() {
+    return this._company;
+  }
+  get modules() {
+    return this._modules;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._name = data.jsonApi.attributes.name;
+    this._email = data.jsonApi.attributes.email;
+    this._title = data.jsonApi.attributes.title;
+    this._bio = data.jsonApi.attributes.bio;
+    this._phone = data.jsonApi.attributes.phone;
+    this._rate = data.jsonApi.attributes.rate;
+    this._avatar = data.jsonApi.attributes.avatar;
+    this._avatarUrl = data.jsonApi.attributes.avatarUrl;
+    this._isActivated = data.jsonApi.meta.isActive;
+    this._isDeleted = data.jsonApi.meta.isDeleted;
+    this._lastLogin = data.jsonApi.meta.lastLogin ? new Date(data.jsonApi.meta.lastLogin) : void 0;
+    this._relevance = data.jsonApi.meta.relevance;
+    this._roles = this._readIncluded(data, "roles", Modules.Role);
+    this._company = this._readIncluded(data, "company", Modules.Company);
+    this._modules = this._readIncluded(data, "modules", Modules.Module);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.User.name,
+        id: data.id,
+        attributes: {
+          name: data.name
+        },
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.email !== void 0) response.data.attributes.email = data.email;
+    if (data.title !== void 0) response.data.attributes.title = data.title;
+    if (data.bio !== void 0) response.data.attributes.bio = data.bio;
+    if (data.phone !== void 0) response.data.attributes.phone = data.phone;
+    if (data.password !== void 0) response.data.attributes.password = data.password;
+    if (data.sendInvitationEmail) response.data.attributes.sendInvitationEmail = true;
+    if (data.adminCreated) response.data.attributes.adminCreated = true;
+    if (data.avatar) response.data.attributes.avatar = data.avatar;
+    if (data.rate !== void 0) response.data.attributes.rate = data.rate;
+    if (data.roleIds) {
+      response.data.relationships.roles = {
+        data: data.roleIds.map((roleId) => ({
+          type: Modules.Role.name,
+          id: roleId
+        }))
+      };
+    }
+    if (data.companyId) {
+      response.data.relationships.company = {
+        data: {
+          type: Modules.Company.name,
+          id: data.companyId
+        }
+      };
+    }
+    return response;
+  }
+};
+
+// src/features/user/data/user.fields.ts
+var UserFields = /* @__PURE__ */ ((UserFields2) => {
+  UserFields2["userId"] = "userId";
+  UserFields2["name"] = "name";
+  UserFields2["email"] = "email";
+  UserFields2["relevance"] = "relevance";
+  UserFields2["createdAt"] = "createdAt";
+  UserFields2["updatedAt"] = "updatedAt";
+  return UserFields2;
+})(UserFields || {});
+
+// src/features/user/data/user.service.ts
+var UserService = class extends AbstractService {
+  static {
+    __name(this, "UserService");
+  }
+  static async findFullUser() {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: "me", childEndpoint: "full" });
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate()
+    });
+  }
+  static async findById(params) {
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.userId }).generate()
+    });
+  }
+  static async findByEmail(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: "email", childEndpoint: params.email });
+    return this.callApi({ type: Modules.User, method: "GET" /* GET */, endpoint: endpoint.generate() });
+  }
+  static async findMany(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User });
+    if (params.roleId) endpoint.addAdditionalParam("roleId", params.roleId);
+    if (params.includeDeleted) endpoint.addAdditionalParam("includeDeleted", "true");
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findManyByContentIds(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User });
+    endpoint.addAdditionalParam("contentIds", params.contentIds.map((id) => id).join(","));
+    endpoint.addAdditionalParam("includeDeleted", "true");
+    endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findRelevant(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Content,
+      id: params.id,
+      childEndpoint: "user-relevance"
+    });
+    if (Modules.User.inclusions?.lists?.fields) endpoint.limitToFields(Modules.User.inclusions.lists.fields);
+    if (Modules.User.inclusions?.lists?.types) endpoint.limitToType(Modules.User.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findManyForAmin(params) {
+    if (!params.companyId) return [];
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Company,
+      id: params.companyId,
+      childEndpoint: Modules.User
+    });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.prev
+    });
+  }
+  static async findAllUsers(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Company,
+      id: params.companyId,
+      childEndpoint: Modules.User
+    });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (params.isDeleted) endpoint.addAdditionalParam("isDeleted", "true");
+    if (params.limitToRoles && params.limitToRoles.length > 0)
+      endpoint.addAdditionalParam("limitToRoles", params.limitToRoles.join(","));
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findAllUsersByRole(params) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Role, id: params.roleId, childEndpoint: Modules.User });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findAllUsersNotInRole(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Role,
+      id: params.roleId,
+      childEndpoint: Modules.User
+    }).addAdditionalParam("notInRole", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.User,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.User,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.User }).generate(),
+      companyId: params.companyId,
+      input: params
+    });
+  }
+  static async reactivate(params) {
+    return this.callApi({
+      type: Modules.User,
+      method: "PATCH" /* PATCH */,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.userId }).generate()
+    });
+  }
+  static async sendInvitation(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.User,
+      id: params.userId,
+      childEndpoint: "send-invitation-email"
+    });
+    if (params.companyId) endpoint.addAdditionalParam("companyId", params.companyId);
+    this.callApi({
+      type: Modules.User,
+      method: "POST" /* POST */,
+      endpoint: endpoint.generate()
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.User,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.id }).generate(),
+      companyId: params.companyId,
+      input: params
+    });
+  }
+  static async patchRate(params) {
+    return this.callApi({
+      type: Modules.User,
+      method: "PATCH" /* PATCH */,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.id, childEndpoint: "rates" }).generate(),
+      companyId: params.companyId,
+      input: params
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.User,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.User, id: params.userId }).generate(),
+      companyId: params.companyId
+    });
+  }
+};
+
+// src/features/user/user.module.ts
+var UserModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/users",
+  name: "users",
+  model: User,
+  moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277",
+  inclusions: {
+    lists: {
+      fields: [
+        createJsonApiInclusion("users", [`name`, `email`, `avatar`, `title`]),
+        createJsonApiInclusion("usertopics", [`level`]),
+        createJsonApiInclusion("userexpertises", [`level`]),
+        createJsonApiInclusion("topics", [`name`])
+      ]
+    }
+  }
+}), "UserModule");
+
+// src/features/user/author.module.ts
+var AuthorModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/authors",
+  name: "authors",
+  model: User,
+  moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277"
+}), "AuthorModule");
+
+export {
+  RehydrationFactory,
+  AbstractApiData,
+  HttpMethod,
+  setGlobalErrorHandler,
+  getGlobalErrorHandler,
+  AbstractService,
+  configureClientJsonApi,
+  getClientApiUrl,
+  getClientAppUrl,
+  getClientTrackablePages,
+  ClientJsonApiGet,
+  ClientJsonApiPost,
+  ClientJsonApiPut,
+  ClientJsonApiPatch,
+  ClientJsonApiDelete,
+  ClientHttpMethod,
+  setClientGlobalErrorHandler,
+  getClientGlobalErrorHandler,
+  ClientAbstractService,
+  ModuleRegistrar,
+  ModuleRegistry,
+  Modules,
+  EndpointCreator,
+  createJsonApiInclusion,
+  rehydrate,
+  rehydrateList,
+  cn,
+  composeRefs,
+  useComposedRefs,
+  useIsMobile,
+  formatDate,
+  exists,
+  TableOptions,
+  getTableOptions,
+  getTableComponents,
+  userObjectSchema,
+  entityObjectSchema,
+  BlockNoteDiffUtil,
+  BlockNoteWordDiffRendererUtil,
+  getIconByModule,
+  getIcon,
+  getIconByModuleName,
+  getLucideIcon,
+  getLucideIconByModule,
+  getLucideIconByModuleName,
+  Action,
+  checkPermissions,
+  checkPermissionsFromServer,
+  getValueFromPath,
+  Auth,
+  configureAuth,
+  getTokenHandler,
+  AuthService,
+  AuthComponent,
+  AuthModule,
+  Company,
+  CompanyFields,
+  CompanyService,
+  CompanyModule,
+  Content,
+  ContentFields,
+  ContentService,
+  ContentModule,
+  Feature,
+  FeatureService,
+  FeatureModule,
+  Module,
+  ModuleModule,
+  Notification,
+  NotificationFields,
+  NotificationService,
+  NotificationModule,
+  Push,
+  PushService,
+  PushModule,
+  Role,
+  RoleFields,
+  RoleService,
+  RoleModule,
+  S3,
+  S3Module,
+  S3Service,
+  User,
+  UserFields,
+  UserService,
+  UserModule,
+  AuthorModule
+};
+//# sourceMappingURL=chunk-4U5CJA44.mjs.map