@carlonicora/nextjs-jsonapi 5.2.0 → 5.4.0

package/dist/{chunk-HNOWSFM5.mjs → chunk-WC63PJSC.mjs}

@@ -6165,6 +6165,1225 @@ var HowToService = class extends AbstractService {
   }
 };
 
+// src/features/email-automation/EmailAutomationModule.ts
+import { MailIcon } from "lucide-react";
+
+// src/features/email-automation/data/EmailAutomation.ts
+var EmailAutomation = class extends AbstractApiData {
+  static {
+    __name(this, "EmailAutomation");
+  }
+  _name;
+  _trigger;
+  _exitTrigger;
+  _replyTo;
+  _isActive = false;
+  _stepCount;
+  _activeCount;
+  _completedCount;
+  _unsubscribedCount;
+  get name() {
+    return this._name ?? "";
+  }
+  get trigger() {
+    return this._trigger;
+  }
+  get exitTrigger() {
+    return this._exitTrigger;
+  }
+  get replyTo() {
+    return this._replyTo;
+  }
+  get isActive() {
+    return this._isActive;
+  }
+  get stepCount() {
+    return this._stepCount ?? 0;
+  }
+  get activeCount() {
+    return this._activeCount ?? 0;
+  }
+  get completedCount() {
+    return this._completedCount ?? 0;
+  }
+  get unsubscribedCount() {
+    return this._unsubscribedCount ?? 0;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._name = data.jsonApi.attributes.name;
+    this._trigger = data.jsonApi.attributes.trigger ?? void 0;
+    this._exitTrigger = data.jsonApi.attributes.exitTrigger ?? void 0;
+    this._replyTo = data.jsonApi.attributes.replyTo ?? void 0;
+    this._isActive = data.jsonApi.attributes.isActive === true;
+    this._stepCount = data.jsonApi.attributes.stepCount;
+    this._activeCount = data.jsonApi.attributes.activeCount;
+    this._completedCount = data.jsonApi.attributes.completedCount;
+    this._unsubscribedCount = data.jsonApi.attributes.unsubscribedCount;
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.EmailAutomation.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.name !== void 0) response.data.attributes.name = data.name;
+    if (data.trigger !== void 0) response.data.attributes.trigger = data.trigger;
+    if (data.exitTrigger !== void 0) response.data.attributes.exitTrigger = data.exitTrigger;
+    if (data.replyTo !== void 0) response.data.attributes.replyTo = data.replyTo;
+    if (data.isActive !== void 0) response.data.attributes.isActive = data.isActive;
+    return response;
+  }
+};
+
+// src/features/email-automation/EmailAutomationModule.ts
+var EmailAutomationModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: "3f6c1a2e-7b94-4d1e-8c55-9a0b2e4f6d71",
+  pageUrl: "/administration/email-automations",
+  name: "email-automations",
+  model: EmailAutomation,
+  icon: MailIcon,
+  inclusions: {
+    lists: {
+      fields: [
+        createJsonApiInclusion("email-automations", [
+          "name",
+          "trigger",
+          "exitTrigger",
+          "replyTo",
+          "isActive",
+          "stepCount",
+          "activeCount",
+          "completedCount",
+          "unsubscribedCount"
+        ])
+      ]
+    }
+  }
+}), "EmailAutomationModule");
+
+// src/features/email-automation/EmailAutomationStepModule.ts
+import { MailIcon as MailIcon2 } from "lucide-react";
+
+// src/features/email-automation/data/EmailAutomationStep.ts
+var EmailAutomationStep = class extends AbstractApiData {
+  static {
+    __name(this, "EmailAutomationStep");
+  }
+  _subject;
+  _body;
+  _delayHours;
+  _positionX;
+  _positionY;
+  _sentCount;
+  _automation;
+  _next;
+  get subject() {
+    return this._subject ?? "";
+  }
+  get body() {
+    return this._body ?? "";
+  }
+  get delayHours() {
+    return this._delayHours ?? 0;
+  }
+  get positionX() {
+    return this._positionX;
+  }
+  get positionY() {
+    return this._positionY;
+  }
+  get sentCount() {
+    return this._sentCount ?? 0;
+  }
+  get automation() {
+    return this._automation;
+  }
+  get next() {
+    return this._next;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._subject = data.jsonApi.attributes.subject;
+    this._body = data.jsonApi.attributes.body;
+    this._delayHours = data.jsonApi.attributes.delayHours;
+    this._positionX = data.jsonApi.attributes.positionX ?? void 0;
+    this._positionY = data.jsonApi.attributes.positionY ?? void 0;
+    this._sentCount = data.jsonApi.attributes.sentCount;
+    this._automation = this._readIncluded(data, "automation", Modules.EmailAutomation);
+    this._next = this._readIncluded(data, "next", Modules.EmailAutomationStep);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.EmailAutomationStep.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.subject !== void 0) response.data.attributes.subject = data.subject;
+    if (data.body !== void 0) response.data.attributes.body = data.body;
+    if (data.delayHours !== void 0) response.data.attributes.delayHours = data.delayHours;
+    if (data.positionX !== void 0) response.data.attributes.positionX = data.positionX;
+    if (data.positionY !== void 0) response.data.attributes.positionY = data.positionY;
+    if (data.automationId) {
+      response.data.relationships.automation = {
+        data: {
+          type: Modules.EmailAutomation.name,
+          id: data.automationId
+        }
+      };
+    }
+    return response;
+  }
+  /**
+   * Body of POST email-automation-steps/:stepId/next: the step the chain continues to.
+   */
+  createNextJsonApi(params) {
+    return {
+      data: {
+        type: Modules.EmailAutomationStep.name,
+        id: params.nextStepId
+      }
+    };
+  }
+};
+
+// src/features/email-automation/EmailAutomationStepModule.ts
+var EmailAutomationStepModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: void 0,
+  name: "email-automation-steps",
+  model: EmailAutomationStep,
+  icon: MailIcon2
+}), "EmailAutomationStepModule");
+
+// src/features/email-automation/EmailAutomationEnrollmentModule.ts
+import { UsersIcon } from "lucide-react";
+
+// src/features/email-automation/data/EmailAutomationEnrollment.ts
+var EMAIL_AUTOMATION_UNSUBSCRIBE_TYPE = "email-automation-unsubscribes";
+var EmailAutomationEnrollment = class extends AbstractApiData {
+  static {
+    __name(this, "EmailAutomationEnrollment");
+  }
+  _email;
+  _name;
+  _status = "active";
+  _enrolledAt;
+  _nextSendAt;
+  _finishedAt;
+  _attempts;
+  _lastError;
+  _currentStepSubject;
+  _sentCount;
+  _automation;
+  get email() {
+    return this._email ?? "";
+  }
+  get name() {
+    return this._name;
+  }
+  get status() {
+    return this._status;
+  }
+  get enrolledAt() {
+    return this._enrolledAt ?? /* @__PURE__ */ new Date(0);
+  }
+  get nextSendAt() {
+    return this._nextSendAt;
+  }
+  get finishedAt() {
+    return this._finishedAt;
+  }
+  get attempts() {
+    return this._attempts ?? 0;
+  }
+  get lastError() {
+    return this._lastError;
+  }
+  get currentStepSubject() {
+    return this._currentStepSubject;
+  }
+  get sentCount() {
+    return this._sentCount ?? 0;
+  }
+  get automation() {
+    return this._automation;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes;
+    this._email = attributes.email;
+    this._name = attributes.name ?? void 0;
+    this._status = attributes.status ?? "active";
+    this._enrolledAt = attributes.enrolledAt ? new Date(attributes.enrolledAt) : void 0;
+    this._nextSendAt = attributes.nextSendAt ? new Date(attributes.nextSendAt) : void 0;
+    this._finishedAt = attributes.finishedAt ? new Date(attributes.finishedAt) : void 0;
+    this._attempts = attributes.attempts;
+    this._lastError = attributes.lastError ?? void 0;
+    this._currentStepSubject = attributes.currentStepSubject ?? void 0;
+    this._sentCount = attributes.sentCount;
+    this._automation = this._readIncluded(data, "automation", Modules.EmailAutomation);
+    return this;
+  }
+  createJsonApi(_data) {
+    throw new Error("EmailAutomationEnrollment is created by the API and cannot be created from the client");
+  }
+  /**
+   * Body of POST email-automations/unsubscribe/:token.
+   */
+  createUnsubscribeJsonApi(params) {
+    return {
+      data: {
+        type: EMAIL_AUTOMATION_UNSUBSCRIBE_TYPE,
+        attributes: {
+          scope: params.scope
+        }
+      }
+    };
+  }
+};
+
+// src/features/email-automation/EmailAutomationEnrollmentModule.ts
+var EmailAutomationEnrollmentModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: void 0,
+  name: "email-automation-enrollments",
+  model: EmailAutomationEnrollment,
+  icon: UsersIcon
+}), "EmailAutomationEnrollmentModule");
+
+// src/features/email-automation/EmailAutomationTriggerModule.ts
+import { ZapIcon } from "lucide-react";
+
+// src/features/email-automation/data/EmailAutomationTrigger.ts
+var EmailAutomationTrigger = class extends AbstractApiData {
+  static {
+    __name(this, "EmailAutomationTrigger");
+  }
+  _key;
+  _label;
+  get key() {
+    return this._key ?? "";
+  }
+  get label() {
+    return this._label ?? "";
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._key = data.jsonApi.attributes.key;
+    this._label = data.jsonApi.attributes.label;
+    return this;
+  }
+  createJsonApi(_data) {
+    throw new Error("EmailAutomationTrigger is declared by the API and is read-only");
+  }
+};
+
+// src/features/email-automation/EmailAutomationTriggerModule.ts
+var EmailAutomationTriggerModule = /* @__PURE__ */ __name((factory) => factory({
+  pageUrl: void 0,
+  name: "email-automation-triggers",
+  model: EmailAutomationTrigger,
+  icon: ZapIcon
+}), "EmailAutomationTriggerModule");
+
+// src/features/email-automation/data/EmailAutomationService.ts
+var EmailAutomationService = class extends AbstractService {
+  static {
+    __name(this, "EmailAutomationService");
+  }
+  static async findMany(params = {}) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.EmailAutomation });
+    if (Modules.EmailAutomation.inclusions?.lists?.fields)
+      endpoint.limitToFields(Modules.EmailAutomation.inclusions.lists.fields);
+    if (Modules.EmailAutomation.inclusions?.lists?.types)
+      endpoint.limitToType(Modules.EmailAutomation.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.EmailAutomation,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.previous
+    });
+  }
+  static async findOne(params) {
+    return this.callApi({
+      type: Modules.EmailAutomation,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: params.id }).generate()
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.EmailAutomation,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation }).generate(),
+      input: params
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.EmailAutomation,
+      method: "PATCH" /* PATCH */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: params.id }).generate(),
+      input: params
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.EmailAutomation,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: params.id }).generate()
+    });
+  }
+  /**
+   * GET email-automations/triggers: the triggers the app declared to the API.
+   */
+  static async findTriggers() {
+    return this.callApi({
+      type: Modules.EmailAutomationTrigger,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: "triggers" }).generate()
+    });
+  }
+  /**
+   * POST email-automations/:id/tidy: clears every manual step position. Replies 204.
+   */
+  static async tidy(params) {
+    await this.callApi({
+      type: Modules.EmailAutomation,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.EmailAutomation,
+        id: params.id,
+        childEndpoint: "tidy"
+      }).generate()
+    });
+  }
+  static async findEnrollments(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.EmailAutomation,
+      id: params.automationId,
+      childEndpoint: Modules.EmailAutomationEnrollment
+    });
+    if (params.status) endpoint.addAdditionalParam("status", params.status);
+    return this.callApi({
+      type: Modules.EmailAutomationEnrollment,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.previous
+    });
+  }
+};
+
+// src/features/email-automation/data/EmailAutomationStepService.ts
+var EmailAutomationStepService = class extends AbstractService {
+  static {
+    __name(this, "EmailAutomationStepService");
+  }
+  static async findByAutomation(params) {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.EmailAutomation,
+      id: params.automationId,
+      childEndpoint: Modules.EmailAutomationStep
+    });
+    endpoint.addAdditionalParam("fetchAll", "true");
+    return this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate()
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomationStep }).generate(),
+      input: params
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: "PATCH" /* PATCH */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomationStep, id: params.id }).generate(),
+      input: params
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomationStep, id: params.id }).generate()
+    });
+  }
+  /**
+   * POST email-automation-steps/:stepId/next: continues the chain from stepId to nextStepId.
+   */
+  static async setNext(params) {
+    const step = new EmailAutomationStep();
+    return this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.EmailAutomationStep,
+        id: params.stepId,
+        childEndpoint: "next"
+      }).generate(),
+      input: step.createNextJsonApi({ nextStepId: params.nextStepId }),
+      overridesJsonApiCreation: true
+    });
+  }
+  /**
+   * DELETE email-automation-steps/:stepId/next: the step becomes the end of the chain.
+   */
+  static async clearNext(params) {
+    await this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.EmailAutomationStep,
+        id: params.stepId,
+        childEndpoint: "next"
+      }).generate()
+    });
+  }
+};
+
+// src/features/email-automation/data/EmailAutomationEnrollmentService.ts
+var EmailAutomationEnrollmentService = class extends AbstractService {
+  static {
+    __name(this, "EmailAutomationEnrollmentService");
+  }
+  /**
+   * POST email-automations/unsubscribe/:token (public). The scope travels both as
+   * a query parameter and in the body, as the API reads either.
+   */
+  static async unsubscribe(params) {
+    const enrollment = new EmailAutomationEnrollment();
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.EmailAutomation,
+      childEndpoint: "unsubscribe",
+      childId: params.token
+    });
+    endpoint.addAdditionalParam("scope", params.scope);
+    return this.callApi({
+      type: Modules.EmailAutomationEnrollment,
+      method: "POST" /* POST */,
+      endpoint: endpoint.generate(),
+      input: enrollment.createUnsubscribeJsonApi({ scope: params.scope }),
+      overridesJsonApiCreation: true
+    });
+  }
+};
+
+// src/features/email-automation/data/email-automation.fields.ts
+var EmailAutomationFields = /* @__PURE__ */ ((EmailAutomationFields2) => {
+  EmailAutomationFields2["name"] = "name";
+  EmailAutomationFields2["trigger"] = "trigger";
+  EmailAutomationFields2["status"] = "status";
+  EmailAutomationFields2["steps"] = "steps";
+  EmailAutomationFields2["active"] = "active";
+  EmailAutomationFields2["completed"] = "completed";
+  EmailAutomationFields2["unsubscribed"] = "unsubscribed";
+  return EmailAutomationFields2;
+})(EmailAutomationFields || {});
+
+// src/features/email-automation/data/email-automation-enrollment.fields.ts
+var EmailAutomationEnrollmentFields = /* @__PURE__ */ ((EmailAutomationEnrollmentFields2) => {
+  EmailAutomationEnrollmentFields2["email"] = "email";
+  EmailAutomationEnrollmentFields2["name"] = "name";
+  EmailAutomationEnrollmentFields2["status"] = "status";
+  EmailAutomationEnrollmentFields2["currentStep"] = "currentStep";
+  EmailAutomationEnrollmentFields2["nextSendAt"] = "nextSendAt";
+  EmailAutomationEnrollmentFields2["sentCount"] = "sentCount";
+  return EmailAutomationEnrollmentFields2;
+})(EmailAutomationEnrollmentFields || {});
+
+// src/features/blog/BlogModules.ts
+import { NewspaperIcon } from "lucide-react";
+
+// src/features/blog/data/BlogCategory.ts
+var BlogCategory = class extends AbstractApiData {
+  static {
+    __name(this, "BlogCategory");
+  }
+  _originalLanguage;
+  _image;
+  _translations;
+  _language;
+  _name;
+  _slug;
+  _description;
+  get originalLanguage() {
+    return this._originalLanguage ?? "";
+  }
+  get image() {
+    return this._image;
+  }
+  get translations() {
+    return this._translations ?? [];
+  }
+  get original() {
+    return this.translations.find((translation) => translation.isOriginal);
+  }
+  get language() {
+    return this._language;
+  }
+  get name() {
+    return this._name;
+  }
+  get slug() {
+    return this._slug;
+  }
+  get description() {
+    return this._description;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes ?? {};
+    const meta = data.jsonApi.meta ?? {};
+    const resolved = /* @__PURE__ */ __name((key) => attributes[key] ?? meta[key] ?? void 0, "resolved");
+    this._originalLanguage = attributes.originalLanguage;
+    this._image = attributes.image ?? void 0;
+    this._language = resolved("language");
+    this._name = resolved("name");
+    this._slug = resolved("slug");
+    this._description = resolved("description");
+    this._translations = this._readIncluded(
+      data,
+      "translations",
+      Modules.BlogCategoryTranslation
+    );
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.BlogCategory.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.originalLanguage !== void 0) response.data.attributes.originalLanguage = data.originalLanguage;
+    if (data.name !== void 0) response.data.attributes.name = data.name;
+    if (data.slug !== void 0) response.data.attributes.slug = data.slug;
+    if (data.description !== void 0) response.data.attributes.description = data.description;
+    if (data.image !== void 0) response.data.attributes.image = data.image;
+    return response;
+  }
+};
+
+// src/features/blog/data/BlogCategoryTranslation.ts
+var BlogCategoryTranslation = class extends AbstractApiData {
+  static {
+    __name(this, "BlogCategoryTranslation");
+  }
+  _language;
+  _isOriginal;
+  _source;
+  _aiStatus;
+  _name;
+  _slug;
+  _description;
+  _translatedAt;
+  _category;
+  get language() {
+    return this._language ?? "";
+  }
+  get isOriginal() {
+    return this._isOriginal ?? false;
+  }
+  get source() {
+    return this._source ?? "ai";
+  }
+  get aiStatus() {
+    return this._aiStatus ?? "pending";
+  }
+  get name() {
+    return this._name ?? "";
+  }
+  get slug() {
+    return this._slug ?? "";
+  }
+  get description() {
+    return this._description;
+  }
+  get translatedAt() {
+    return this._translatedAt;
+  }
+  get category() {
+    return this._category;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes ?? {};
+    this._language = attributes.language;
+    this._isOriginal = attributes.isOriginal === true;
+    this._source = attributes.source;
+    this._aiStatus = attributes.aiStatus;
+    this._name = attributes.name ?? void 0;
+    this._slug = attributes.slug ?? void 0;
+    this._description = attributes.description ?? void 0;
+    this._translatedAt = attributes.translatedAt ? new Date(attributes.translatedAt) : void 0;
+    this._category = this._readIncluded(data, "category", Modules.BlogCategory);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.BlogCategoryTranslation.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.name !== void 0) response.data.attributes.name = data.name;
+    if (data.slug !== void 0) response.data.attributes.slug = data.slug;
+    if (data.description !== void 0) response.data.attributes.description = data.description;
+    return response;
+  }
+};
+
+// src/features/blog/data/BlogPost.ts
+var BlogPost = class extends AbstractApiData {
+  static {
+    __name(this, "BlogPost");
+  }
+  _status;
+  _originalLanguage;
+  _coverImage;
+  _publishedAt;
+  _author;
+  _categories;
+  _translations;
+  _language;
+  _title;
+  _slug;
+  _summary;
+  _body;
+  _coverImageAlt;
+  _readingMinutes;
+  _authorName;
+  _categoryIds;
+  get status() {
+    return this._status ?? "draft";
+  }
+  get originalLanguage() {
+    return this._originalLanguage ?? "";
+  }
+  get coverImage() {
+    return this._coverImage;
+  }
+  get publishedAt() {
+    return this._publishedAt;
+  }
+  get author() {
+    return this._author;
+  }
+  get categories() {
+    return this._categories ?? [];
+  }
+  get translations() {
+    return this._translations ?? [];
+  }
+  get original() {
+    return this.translations.find((translation) => translation.isOriginal);
+  }
+  get language() {
+    return this._language;
+  }
+  get title() {
+    return this._title;
+  }
+  get slug() {
+    return this._slug;
+  }
+  get summary() {
+    return this._summary;
+  }
+  get body() {
+    return this._body ?? [];
+  }
+  get coverImageAlt() {
+    return this._coverImageAlt;
+  }
+  get readingMinutes() {
+    return this._readingMinutes;
+  }
+  get authorName() {
+    return this._authorName;
+  }
+  get categoryIds() {
+    return this._categoryIds ?? [];
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes ?? {};
+    const meta = data.jsonApi.meta ?? {};
+    const resolved = /* @__PURE__ */ __name((key) => attributes[key] ?? meta[key] ?? void 0, "resolved");
+    this._status = attributes.status;
+    this._originalLanguage = attributes.originalLanguage;
+    this._coverImage = attributes.coverImage ?? void 0;
+    this._publishedAt = attributes.publishedAt ? new Date(attributes.publishedAt) : void 0;
+    this._language = resolved("language");
+    this._title = resolved("title");
+    this._slug = resolved("slug");
+    this._summary = resolved("summary");
+    const body = resolved("body");
+    this._body = body ? JSON.parse(body) : void 0;
+    this._coverImageAlt = resolved("coverImageAlt");
+    this._readingMinutes = resolved("readingMinutes");
+    this._authorName = resolved("authorName");
+    this._categoryIds = resolved("categoryIds") ?? [];
+    this._author = this._readIncluded(data, "author", Modules.User);
+    this._categories = this._readIncluded(data, "categories", Modules.BlogCategory);
+    this._translations = this._readIncluded(
+      data,
+      "translations",
+      Modules.BlogPostTranslation
+    );
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.BlogPost.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.originalLanguage !== void 0) response.data.attributes.originalLanguage = data.originalLanguage;
+    if (data.title !== void 0) response.data.attributes.title = data.title;
+    if (data.slug !== void 0) response.data.attributes.slug = data.slug;
+    if (data.summary !== void 0) response.data.attributes.summary = data.summary;
+    if (data.body !== void 0) response.data.attributes.body = JSON.stringify(data.body);
+    if (data.coverImage !== void 0) response.data.attributes.coverImage = data.coverImage;
+    if (data.coverImageAlt !== void 0) response.data.attributes.coverImageAlt = data.coverImageAlt;
+    if (data.categoryIds !== void 0) {
+      response.data.relationships.categories = {
+        data: data.categoryIds.map((id) => ({ type: Modules.BlogCategory.name, id }))
+      };
+    }
+    return response;
+  }
+};
+
+// src/features/blog/data/BlogPostTranslation.ts
+var BlogPostTranslation = class extends AbstractApiData {
+  static {
+    __name(this, "BlogPostTranslation");
+  }
+  _language;
+  _isOriginal;
+  _source;
+  _aiStatus;
+  _title;
+  _slug;
+  _summary;
+  _body;
+  _coverImageAlt;
+  _readingMinutes;
+  _translatedAt;
+  _post;
+  get language() {
+    return this._language ?? "";
+  }
+  get isOriginal() {
+    return this._isOriginal ?? false;
+  }
+  get source() {
+    return this._source ?? "ai";
+  }
+  get aiStatus() {
+    return this._aiStatus ?? "pending";
+  }
+  get title() {
+    return this._title ?? "";
+  }
+  get slug() {
+    return this._slug ?? "";
+  }
+  get summary() {
+    return this._summary;
+  }
+  get body() {
+    return this._body ?? [];
+  }
+  get coverImageAlt() {
+    return this._coverImageAlt;
+  }
+  get readingMinutes() {
+    return this._readingMinutes ?? 1;
+  }
+  get translatedAt() {
+    return this._translatedAt;
+  }
+  get post() {
+    return this._post;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes ?? {};
+    this._language = attributes.language;
+    this._isOriginal = attributes.isOriginal === true;
+    this._source = attributes.source;
+    this._aiStatus = attributes.aiStatus;
+    this._title = attributes.title ?? void 0;
+    this._slug = attributes.slug ?? void 0;
+    this._summary = attributes.summary ?? void 0;
+    this._body = attributes.body ? JSON.parse(attributes.body) : void 0;
+    this._coverImageAlt = attributes.coverImageAlt ?? void 0;
+    this._readingMinutes = attributes.readingMinutes ?? void 0;
+    this._translatedAt = attributes.translatedAt ? new Date(attributes.translatedAt) : void 0;
+    this._post = this._readIncluded(data, "post", Modules.BlogPost);
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.BlogPostTranslation.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.title !== void 0) response.data.attributes.title = data.title;
+    if (data.slug !== void 0) response.data.attributes.slug = data.slug;
+    if (data.summary !== void 0) response.data.attributes.summary = data.summary;
+    if (data.body !== void 0) response.data.attributes.body = JSON.stringify(data.body);
+    if (data.coverImageAlt !== void 0) response.data.attributes.coverImageAlt = data.coverImageAlt;
+    return response;
+  }
+};
+
+// src/features/blog/types/blog.constants.ts
+var BLOG_LIST_LAYOUTS = ["featured", "column", "rail"];
+var BLOG_POST_STATUSES = ["draft", "published", "unpublished"];
+var BLOG_TRANSLATION_SOURCES = ["original", "ai", "manual"];
+var BLOG_SETTINGS_ID = "5f3c2a9e-8d41-4b7a-9c2e-1a6b0d4e7f13";
+var BLOG_MODULE_ID = "c1d0e6a2-4b8f-4f3e-9a7d-2e5b8c6f1a90";
+var BLOG_UPLOAD_ROOT = "blog";
+var BLOG_POST_UPLOAD_PREFIX = `${BLOG_UPLOAD_ROOT}/blog-posts`;
+var BLOG_CATEGORY_UPLOAD_PREFIX = `${BLOG_UPLOAD_ROOT}/blog-categories`;
+var BLOG_PUBLIC_PREFIX = "public";
+var BLOG_ACTION = {
+  publish: "publish",
+  unpublish: "unpublish",
+  retranslate: "retranslate",
+  related: "related"
+};
+
+// src/features/blog/data/BlogSettings.ts
+var BlogSettings = class extends AbstractApiData {
+  static {
+    __name(this, "BlogSettings");
+  }
+  _listLayout;
+  get listLayout() {
+    return this._listLayout ?? "featured";
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const listLayout = data.jsonApi.attributes?.listLayout;
+    this._listLayout = BLOG_LIST_LAYOUTS.includes(listLayout) ? listLayout : void 0;
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.BlogSettings.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {}
+      },
+      included: []
+    };
+    response.data.attributes.listLayout = data.listLayout;
+    return response;
+  }
+};
+
+// src/features/blog/BlogModules.ts
+var BlogPostModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: BLOG_MODULE_ID,
+  pageUrl: "/administration/blog",
+  name: "blog-posts",
+  model: BlogPost,
+  icon: NewspaperIcon
+}), "BlogPostModule");
+var BlogPostTranslationModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: BLOG_MODULE_ID,
+  name: "blog-post-translations",
+  model: BlogPostTranslation,
+  icon: NewspaperIcon
+}), "BlogPostTranslationModule");
+var BlogCategoryModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: BLOG_MODULE_ID,
+  name: "blog-categories",
+  model: BlogCategory,
+  icon: NewspaperIcon
+}), "BlogCategoryModule");
+var BlogCategoryTranslationModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: BLOG_MODULE_ID,
+  name: "blog-category-translations",
+  model: BlogCategoryTranslation,
+  icon: NewspaperIcon
+}), "BlogCategoryTranslationModule");
+var BlogSettingsModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: BLOG_MODULE_ID,
+  name: "blog-settings",
+  model: BlogSettings,
+  icon: NewspaperIcon
+}), "BlogSettingsModule");
+
+// src/features/blog/data/BlogPostService.ts
+var BlogPostService = class extends AbstractService {
+  static {
+    __name(this, "BlogPostService");
+  }
+  static async findMany(params = {}) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.BlogPost });
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.BlogPost,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findOne(params) {
+    return this.callApi({
+      type: Modules.BlogPost,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogPost, id: params.id }).generate()
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.BlogPost,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogPost }).generate(),
+      input: params
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.BlogPost,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogPost, id: params.id }).generate(),
+      input: params
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.BlogPost,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogPost, id: params.id }).generate()
+    });
+  }
+  /**
+   * POST blog-posts/:id/publish. Sends no body; replies with the post.
+   */
+  static async publish(params) {
+    return this.callApi({
+      type: Modules.BlogPost,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.BlogPost,
+        id: params.id,
+        childEndpoint: BLOG_ACTION.publish
+      }).generate()
+    });
+  }
+  /**
+   * POST blog-posts/:id/unpublish. Sends no body; replies with the post.
+   */
+  static async unpublish(params) {
+    return this.callApi({
+      type: Modules.BlogPost,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.BlogPost,
+        id: params.id,
+        childEndpoint: BLOG_ACTION.unpublish
+      }).generate()
+    });
+  }
+};
+
+// src/features/blog/data/BlogPostTranslationService.ts
+var BlogPostTranslationService = class extends AbstractService {
+  static {
+    __name(this, "BlogPostTranslationService");
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.BlogPostTranslation,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogPostTranslation, id: params.id }).generate(),
+      input: params
+    });
+  }
+  /**
+   * POST blog-post-translations/:id/retranslate. Re-queues this one language
+   * from the current original. Replies 204.
+   */
+  static async retranslate(params) {
+    await this.callApi({
+      type: Modules.BlogPostTranslation,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.BlogPostTranslation,
+        id: params.id,
+        childEndpoint: BLOG_ACTION.retranslate
+      }).generate()
+    });
+  }
+};
+
+// src/features/blog/data/BlogCategoryService.ts
+var BlogCategoryService = class extends AbstractService {
+  static {
+    __name(this, "BlogCategoryService");
+  }
+  static async findMany(params = {}) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.BlogCategory });
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    return this.callApi({
+      type: Modules.BlogCategory,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findOne(params) {
+    return this.callApi({
+      type: Modules.BlogCategory,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory, id: params.id }).generate()
+    });
+  }
+  static async create(params) {
+    return this.callApi({
+      type: Modules.BlogCategory,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory }).generate(),
+      input: params
+    });
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.BlogCategory,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory, id: params.id }).generate(),
+      input: params
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.BlogCategory,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategory, id: params.id }).generate()
+    });
+  }
+};
+
+// src/features/blog/data/BlogCategoryTranslationService.ts
+var BlogCategoryTranslationService = class extends AbstractService {
+  static {
+    __name(this, "BlogCategoryTranslationService");
+  }
+  static async update(params) {
+    return this.callApi({
+      type: Modules.BlogCategoryTranslation,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogCategoryTranslation, id: params.id }).generate(),
+      input: params
+    });
+  }
+  /**
+   * POST blog-category-translations/:id/retranslate. Re-queues this one
+   * language from the current original. Replies 204.
+   */
+  static async retranslate(params) {
+    await this.callApi({
+      type: Modules.BlogCategoryTranslation,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.BlogCategoryTranslation,
+        id: params.id,
+        childEndpoint: BLOG_ACTION.retranslate
+      }).generate()
+    });
+  }
+};
+
+// src/features/blog/data/BlogSettingsService.ts
+var BlogSettingsService = class extends AbstractService {
+  static {
+    __name(this, "BlogSettingsService");
+  }
+  /**
+   * GET blog-settings: the stored singleton, or the API's default.
+   */
+  static async get() {
+    return this.callApi({
+      type: Modules.BlogSettings,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogSettings }).generate()
+    });
+  }
+  static async save(params) {
+    return this.callApi({
+      type: Modules.BlogSettings,
+      method: "PUT" /* PUT */,
+      endpoint: new EndpointCreator({ endpoint: Modules.BlogSettings, id: params.id }).generate(),
+      input: params
+    });
+  }
+};
+
+// src/features/blog/data/BlogPostFields.ts
+var BlogPostFields = /* @__PURE__ */ ((BlogPostFields2) => {
+  BlogPostFields2["title"] = "title";
+  BlogPostFields2["status"] = "status";
+  BlogPostFields2["categories"] = "categories";
+  BlogPostFields2["publishedAt"] = "publishedAt";
+  BlogPostFields2["languages"] = "languages";
+  return BlogPostFields2;
+})(BlogPostFields || {});
+
+// src/features/blog/data/BlogCategoryFields.ts
+var BlogCategoryFields = /* @__PURE__ */ ((BlogCategoryFields2) => {
+  BlogCategoryFields2["name"] = "name";
+  BlogCategoryFields2["languages"] = "languages";
+  return BlogCategoryFields2;
+})(BlogCategoryFields || {});
+
 // src/features/handbook/HandbookPageModule.ts
 import { BookOpenIcon } from "lucide-react";
 
@@ -7946,6 +9165,20 @@ var S3Service = class extends AbstractService {
     if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
     return this.callApi({ type: Modules.S3, method: "GET" /* GET */, endpoint: endpoint.generate() });
   }
+  /**
+   * Presigns `key` and PUTs `file` to the presigned S3 URL. The PUT goes straight
+   * to object storage (not the JSON:API backend), so it cannot use callApi.
+   * Throws when the upload is rejected.
+   */
+  static async upload(params) {
+    const s3 = await this.getPreSignedUrl({
+      key: params.key,
+      contentType: params.contentType,
+      isPublic: params.isPublic
+    });
+    const response = await fetch(s3.url, { method: "PUT", headers: s3.headers, body: params.file });
+    if (!response.ok) throw new Error(`S3 upload failed: ${response.status}`);
+  }
   static async getSignedUrl(params) {
     const endpoint = new EndpointCreator({ endpoint: Modules.S3, id: "sign" }).addAdditionalParam("key", params.key);
     if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
@@ -8326,13 +9559,13 @@ var AuthorModule = /* @__PURE__ */ __name((factory) => factory({
 }), "AuthorModule");
 
 // src/features/user/user.module.ts
-import { UsersIcon } from "lucide-react";
+import { UsersIcon as UsersIcon2 } from "lucide-react";
 var UserModule = /* @__PURE__ */ __name((factory) => factory({
   pageUrl: "/users",
   name: "users",
   model: User,
   moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277",
-  icon: UsersIcon,
+  icon: UsersIcon2,
   inclusions: {
     lists: {
       fields: [
@@ -10103,6 +11336,7 @@ export {
   getI18nLink,
   useI18nLocale,
   useI18nDateFnsLocale,
+  getI18nSupportedLocales,
   HttpMethod,
   setGlobalErrorHandler,
   getGlobalErrorHandler,
@@ -10253,6 +11487,47 @@ export {
   HowToModule,
   HowToFields,
   HowToService,
+  EmailAutomation,
+  EmailAutomationModule,
+  EmailAutomationStep,
+  EmailAutomationStepModule,
+  EMAIL_AUTOMATION_UNSUBSCRIBE_TYPE,
+  EmailAutomationEnrollment,
+  EmailAutomationEnrollmentModule,
+  EmailAutomationTrigger,
+  EmailAutomationTriggerModule,
+  EmailAutomationService,
+  EmailAutomationStepService,
+  EmailAutomationEnrollmentService,
+  EmailAutomationFields,
+  EmailAutomationEnrollmentFields,
+  BlogCategory,
+  BlogCategoryTranslation,
+  BlogPost,
+  BlogPostTranslation,
+  BLOG_LIST_LAYOUTS,
+  BLOG_POST_STATUSES,
+  BLOG_TRANSLATION_SOURCES,
+  BLOG_SETTINGS_ID,
+  BLOG_MODULE_ID,
+  BLOG_UPLOAD_ROOT,
+  BLOG_POST_UPLOAD_PREFIX,
+  BLOG_CATEGORY_UPLOAD_PREFIX,
+  BLOG_PUBLIC_PREFIX,
+  BLOG_ACTION,
+  BlogSettings,
+  BlogPostModule,
+  BlogPostTranslationModule,
+  BlogCategoryModule,
+  BlogCategoryTranslationModule,
+  BlogSettingsModule,
+  BlogPostService,
+  BlogPostTranslationService,
+  BlogCategoryService,
+  BlogCategoryTranslationService,
+  BlogSettingsService,
+  BlogPostFields,
+  BlogCategoryFields,
   HandbookPage,
   HandbookPageModule,
   HandbookSection,
@@ -10352,4 +11627,4 @@ export {
   AuditLogService,
   AuditLogModule
 };
-//# sourceMappingURL=chunk-HNOWSFM5.mjs.map
+//# sourceMappingURL=chunk-WC63PJSC.mjs.map