@carlonicora/nextjs-jsonapi 0.0.1

package/dist/chunk-GYWPEPOH.mjs

@@ -0,0 +1,1354 @@
+import {
+  JsonApiDelete,
+  JsonApiGet,
+  JsonApiPost
+} from "./chunk-ECDTZBYO.mjs";
+import {
+  AbstractApiData,
+  AbstractService,
+  EndpointCreator,
+  Modules,
+  createJsonApiInclusion,
+  rehydrate
+} from "./chunk-L6EQEAXU.mjs";
+import {
+  __name
+} from "./chunk-PAWJFY3S.mjs";
+
+// src/features/auth/auth.module.ts
+var AuthModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/auth",
+  name: "auth",
+  model: Auth
+}), "AuthModule");
+
+// 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/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/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/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/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["topic"] = "topic";
+  ContentFields2["expertise"] = "expertise";
+  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/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/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/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/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/author.module.ts
+var AuthorModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: "/authors",
+  name: "authors",
+  model: User,
+  moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277"
+}), "AuthorModule");
+
+export {
+  AuthModule,
+  Auth,
+  configureAuth,
+  AuthService,
+  CompanyModule,
+  Company,
+  CompanyFields,
+  CompanyService,
+  ContentModule,
+  Content,
+  ContentFields,
+  ContentService,
+  Feature,
+  FeatureService,
+  FeatureModule,
+  Module,
+  ModuleModule,
+  Notification,
+  NotificationFields,
+  NotificationService,
+  NotificationModule,
+  Push,
+  PushService,
+  PushModule,
+  Role,
+  RoleFields,
+  RoleService,
+  RoleModule,
+  S3,
+  S3Service,
+  S3Module,
+  User,
+  UserFields,
+  UserService,
+  AuthorModule
+};
+//# sourceMappingURL=chunk-GYWPEPOH.mjs.map